Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Refactor core subsystems and expand test coverage

Yuechen Li23fa1db5202c
diff --git a/Aetheris.Kernel.Firmament.Tests/SemanticEdgeProfileM2Tests.cs b/Aetheris.Kernel.Firmament.Tests/SemanticEdgeProfileM2Tests.cs
new file mode 100644
index 00000000..0e5631c2
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/SemanticEdgeProfileM2Tests.cs
@@ -0,0 +1,158 @@
+using Aetheris.Kernel.Firmament.FirmamentV2;
+using Aetheris.Kernel.Firmament.Materializer;
+using Aetheris.Semantics;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class SemanticEdgeProfileM2Tests
+{
+ [Fact]
+ public void Firmament_RectangleEdgeProgramsComposeAndExtrudeWithoutManualCarrierSpans()
+ {
+ const string source = """
+ Rect2 PlateBase { Center: [0mm, 0mm]; Size: [100mm, 60mm] }
+ EdgeProfile PlateBase.Bottom {
+ Notch CableNotch { FromStart: 18mm; Width: 8mm; Depth: 4mm; Side: Left }
+ Tab MountTab { CenteredAt: 50mm; Width: 12mm; Extension: 6mm; Side: Right }
+ }
+ EdgeProfile PlateBase.Top {
+ Cutback HandlingCutback { FromEnd: 10mm; Run: 8mm; Offset: 3mm; Side: Right }
+ }
+ Profile Plate From PlateBase
+ Extrude Solid { Profile: Plate; From: 0mm; To: 3mm }
+ """;
+
+ var parsed = ProfileAuthoringParser.Parse(source);
+
+ Assert.Empty(parsed.Diagnostics);
+ Assert.NotNull(parsed.Profile);
+ Assert.True(ResolvedProfile2DValidator.Validate(parsed.Profile!).IsValid);
+ Assert.Equal(LineArcProfileExtrudeStatus.Succeeded, ResolvedProfile2DValidator.Extrude(parsed.Profile!, parsed.Height).Status);
+ var segments = parsed.Profile.Loops.Single().Segments;
+ Assert.Equal(3, segments.Count(x => x.Provenance.ConceptStableId == "concept-path:PlateBase.Bottom.MountTab"));
+ Assert.Contains(segments, x => x.Provenance.ConceptStableId == "concept-path:PlateBase.Bottom.Carrier00");
+ Assert.Equal(2, segments.Count(x => x.Provenance.ConceptStableId == "concept-path:PlateBase.Top.HandlingCutback"));
+
+ var root = FirmamentSemanticValues.FromProfilesAndConceptPaths(source).Single(x => x.ExposedName == "Plate");
+ var reference = new SemanticReference(root, [], new("test", 0, 1));
+ Assert.True(SemanticValueValidator.TryResolveMember(reference, new("Bottom", new("test", 0, 1)), out var bottom, out var bottomDiagnostic), bottomDiagnostic?.Message);
+ Assert.True(SemanticValueValidator.TryResolveMember(bottom!, new("MountTab", new("test", 0, 1)), out var tab, out var tabDiagnostic), tabDiagnostic?.Message);
+ Assert.Equal("Tab", tab!.Value.Type.Name);
+ }
+
+ [Fact]
+ public void Resolver_OrdersIndependentAnchorsAndGeneratesCarrierSpans()
+ {
+ var ir = Edge(
+ new SemanticEdgeNotchIr("RightNotch", "Plate.Bottom.RightNotch", new(SemanticEdgeAnchorKind.FromEnd, 10), 8, 3, 1, "test"),
+ new SemanticEdgeTabIr("MountTab", "Plate.Bottom.MountTab", new(SemanticEdgeAnchorKind.CenteredAt, 50), 12, 6, -1, "test"));
+
+ var resolved = SemanticEdgeProfileResolver.Resolve(ir);
+
+ Assert.True(resolved.IsSuccess, string.Join('\n', resolved.Diagnostics));
+ Assert.Equal(["Carrier", "Tab", "Carrier", "Notch", "Carrier"], resolved.Profile!.OrderedMembers.Select(x => x.Kind));
+ Assert.Equal(3, resolved.Profile.OrderedMembers.Single(x => x.StableId == "Plate.Bottom.MountTab").CurveDescendants.Count);
+ Assert.All(resolved.Profile.OrderedMembers.Where(x => x.IsGeneratedCarrier), x => Assert.StartsWith("Plate.Bottom.Carrier", x.StableId));
+ }
+
+ [Fact]
+ public void GenericTemplate_PreservesNestedEdgeFragmentPathAcrossSpecialization()
+ {
+ const string source = """
+ Model TemplateEdgeAttachment {
+ Units: mm
+ Record Spec { Width: Length TabWidth: Length TabDepth: Length Thickness: Length }
+ Static Chosen: Spec = Spec { Width: 100mm TabWidth: 12mm TabDepth: 6mm Thickness: 3mm }
+ Template < P: Spec >
+ Struct PlateTemplate {
+ Rect2 PlateBase { Center: [0mm, 0mm]; Size: [P.Width, 60mm] }
+ EdgeProfile PlateBase.Bottom {
+ Tab MountTab { CenteredAt: 50mm; Width: P.TabWidth; Extension: P.TabDepth; Side: Right }
+ }
+ Profile Plate From PlateBase
+ Extrude Solid { Profile: Plate; From: 0mm; To: P.Thickness }
+ }
+ Struct Product = PlateTemplate < P: Chosen >
+ }
+ """;
+ var diagnostics = new List<string>();
+
+ var root = FirmamentSemanticValues.FromProfilesAndConceptPaths(source, reportedDiagnostics: diagnostics).Single(x => x.ExposedName == "Plate");
+
+ Assert.Empty(diagnostics);
+ var reference = new SemanticReference(root, [], new("test", 0, 1));
+ Assert.True(SemanticValueValidator.TryResolveMember(reference, new("Bottom", new("test", 0, 1)), out var bottom, out _));
+ Assert.True(SemanticValueValidator.TryResolveMember(bottom!, new("MountTab", new("test", 0, 1)), out var tab, out _));
+ Assert.Equal("Tab", tab!.Value.Type.Name);
+ Assert.Contains(root.Provenance, x => x.Stage == "template-specialization");
+ }
+
+ [Fact]
+ public void Resolver_DeclarationOrderDoesNotAffectGeometryOrHash()
+ {
+ var a = new SemanticEdgeTabIr("A", "Plate.Bottom.A", new(SemanticEdgeAnchorKind.FromStart, 10), 10, 4, -1, "test");
+ var b = new SemanticEdgeCutbackIr("B", "Plate.Bottom.B", new(SemanticEdgeAnchorKind.FromEnd, 10), 10, 3, 1, "test");
+
+ var first = SemanticEdgeProfileResolver.Resolve(Edge(a, b)).Profile!;
+ var second = SemanticEdgeProfileResolver.Resolve(Edge(b, a)).Profile!;
+
+ Assert.Equal(first.DeterministicHash, second.DeterministicHash);
+ Assert.Equal(first.OrderedMembers.Select(x => x.StableId), second.OrderedMembers.Select(x => x.StableId));
+ }
+
+ [Fact]
+ public void Resolver_ReportsBothOverlappingSemanticPaths()
+ {
+ var result = SemanticEdgeProfileResolver.Resolve(Edge(
+ new SemanticEdgeTabIr("Tab", "Plate.Bottom.Tab", new(SemanticEdgeAnchorKind.FromStart, 10), 30, 4, -1, "test"),
+ new SemanticEdgeNotchIr("Notch", "Plate.Bottom.Notch", new(SemanticEdgeAnchorKind.FromStart, 25), 20, 3, 1, "test")));
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains("semantic-edge-fragment-overlap:Plate.Bottom:Plate.Bottom.Tab:Plate.Bottom.Notch", result.Diagnostics);
+ }
+
+ [Fact]
+ public void Firmament_BadOwnerMemberFailsBeforeContourMaterialization()
+ {
+ const string source = """
+ Rect2 PlateBase { Center: [0mm, 0mm]; Size: [100mm, 60mm] }
+ EdgeProfile PlateBase.Diagonal { Tab Bad { FromStart: 10mm; Width: 5mm; Extension: 2mm; Side: Right } }
+ Profile Plate From PlateBase
+ Extrude Solid { Profile: Plate; From: 0mm; To: 3mm }
+ """;
+
+ var parsed = ProfileAuthoringParser.Parse(source);
+
+ Assert.Null(parsed.Profile);
+ Assert.Contains("semantic-edge-owner-member-missing:PlateBase.Diagonal:available=Bottom,Right,Top,Left", parsed.Diagnostics);
+ }
+
+ [Theory]
+ [InlineData(-1, "semantic-edge-fragment-out-of-bounds")]
+ [InlineData(96, "semantic-edge-fragment-out-of-bounds")]
+ public void Resolver_RejectsOutOfBoundsFragments(double offset, string code)
+ {
+ var result = SemanticEdgeProfileResolver.Resolve(Edge(
+ new SemanticEdgeTabIr("Tab", "Plate.Bottom.Tab", new(SemanticEdgeAnchorKind.FromStart, offset), 5, 2, -1, "test")));
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, x => x.StartsWith(code, StringComparison.Ordinal));
+ }
+
+ [Fact]
+ public void Resolver_EdgeLengthChangePreservesFragmentPathsAndAdjustsCarrier()
+ {
+ var fragment = new SemanticEdgeTabIr("Tab", "Plate.Bottom.Tab", new(SemanticEdgeAnchorKind.FromEnd, 10), 10, 2, -1, "test");
+ var shortEdge = SemanticEdgeProfileResolver.Resolve(Edge(fragment)).Profile!;
+ var longEdge = SemanticEdgeProfileResolver.Resolve(EdgeTo(120, fragment)).Profile!;
+
+ Assert.Contains(shortEdge.OrderedMembers, x => x.StableId == fragment.StableId);
+ Assert.Contains(longEdge.OrderedMembers, x => x.StableId == fragment.StableId);
+ Assert.Equal(80, shortEdge.OrderedMembers.First(x => x.IsGeneratedCarrier).EndU, 8);
+ Assert.Equal(100, longEdge.OrderedMembers.First(x => x.IsGeneratedCarrier).EndU, 8);
+ }
+
+ private static SemanticEdgeProfileIr Edge(params SemanticEdgeFragmentIr[] fragments) => EdgeTo(100, fragments);
+ private static SemanticEdgeProfileIr EdgeTo(double length, params SemanticEdgeFragmentIr[] fragments) =>
+ new("Plate.Bottom", "Plate.Bottom", new(0, 0), new(length, 0), fragments, "Plate.Bottom[u,v]", "test");
+}
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentSemanticValues.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentSemanticValues.cs
index 8a81b03b..2f98263b 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentSemanticValues.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentSemanticValues.cs
@@ -66,6 +66,7 @@ public static class FirmamentSemanticValues
{
new($"concept-path:{inspection.Name}.Start", new("Point2"), provenance: [new("concept-path", inspection.Name, "validated start", authoredSpan)], authoredSourceSpan: authoredSpan, generatedSourceSpan: expansion is null ? null : span, exposedName: "Start")
};
+ var edgeMembers = new Dictionary<string, List<SemanticValue>>(StringComparer.Ordinal);
foreach (var entry in inspection.Entries)
{
var stepMatch = Regex.Match(expanded, $@"\b(?:Line|Arc|Close)\s+{Regex.Escape(entry.Name)}\b", RegexOptions.CultureInvariant);
@@ -76,8 +77,21 @@ public static class FirmamentSemanticValues
$"{entry.GuideId}.curve{ordinal:D2}", new("ExactProfileCurve"),
provenance: [new("semantic-profile-lowering", entry.Name, $"exact curve descendant {ordinal}", memberAuthoredSpan)],
authoredSourceSpan: memberAuthoredSpan, generatedSourceSpan: expansion is null ? null : stepSpan, exposedName: $"Curve{ordinal:D2}")).ToArray();
- members.Add(new SemanticValue(entry.GuideId, new(entry.SemanticKind ?? entry.Kind), exposedMembers: [end, .. descendants], provenance: [new("semantic-profile-member", entry.Name, $"{entry.CurveCount} exact curve descendant(s)", memberAuthoredSpan)], authoredSourceSpan: memberAuthoredSpan, generatedSourceSpan: expansion is null ? null : stepSpan, exposedName: entry.Name));
+ var exposedName = entry.Name; var dot = entry.Name.IndexOf('.');
+ if (dot >= 0) exposedName = entry.Name[(dot + 1)..];
+ var semanticMember = new SemanticValue(entry.GuideId, new(entry.SemanticKind ?? entry.Kind), exposedMembers: [end, .. descendants], provenance: [new("semantic-profile-member", entry.Name, $"{entry.CurveCount} exact curve descendant(s)", memberAuthoredSpan)], authoredSourceSpan: memberAuthoredSpan, generatedSourceSpan: expansion is null ? null : stepSpan, exposedName: exposedName);
+ if (dot < 0) members.Add(semanticMember);
+ else
+ {
+ var edge = entry.Name[..dot];
+ if (!edgeMembers.TryGetValue(edge, out var nested)) edgeMembers[edge] = nested = [];
+ nested.Add(semanticMember);
+ }
}
+ members.AddRange(edgeMembers.OrderBy(x => x.Key, StringComparer.Ordinal).Select(pair => new SemanticValue(
+ $"concept-path:{inspection.Name}.{pair.Key}", new("SemanticEdge"),
+ exposedMembers: pair.Value, provenance: [new("semantic-edge-owner", inspection.Name, pair.Key, authoredSpan)],
+ authoredSourceSpan: authoredSpan, generatedSourceSpan: expansion is null ? null : span, exposedName: pair.Key)));
var capabilities = new List<ISemanticCapability>();
var bindings = new List<SemanticBinding>();
if (profiles.Values.FirstOrDefault(profile => inspection.Consumers?.Any(consumer => consumer.Kind == "Profile" && consumer.Name == profile.Name) == true) is { } profile)
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs b/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
index cc41c0b9..2743c95d 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
@@ -177,9 +177,69 @@ public static class ProfileAuthoringParser
}
result[name] = path;
}
+ BindRectEdgeProfiles(source, result, diagnostics);
return result;
}
+ private static void BindRectEdgeProfiles(string source, Dictionary<string, BoundPath> result, List<string> diagnostics)
+ {
+ var programs = FindBlocks(source, @"\bEdgeProfile\s+(?<owner>[A-Za-z_]\w*)\.(?<edge>[A-Za-z_]\w*)\s*\{").ToArray();
+ foreach (Match rectangle in Rect.Matches(source))
+ {
+ var name = rectangle.Groups["n"].Value;
+ var isProfileSource = Regex.IsMatch(source, $@"\bProfile\s+[A-Za-z_]\w*\s+From\s+{Regex.Escape(name)}\b", RegexOptions.CultureInvariant);
+ if (!isProfileSource && !programs.Any(x => x.Match.Groups["owner"].Value == name)) continue;
+ if (!TryNumber(rectangle.Groups["w"].Value, out var width) || !TryNumber(rectangle.Groups["h"].Value, out var height) ||
+ !TryNumber(rectangle.Groups["x"].Value, out var cx) || !TryNumber(rectangle.Groups["y"].Value, out var cy)) continue;
+ if (result.ContainsKey(name)) { diagnostics.Add($"profile-edge-owner-name-collision:{name}"); continue; }
+ var bl = (X: cx - width / 2, Y: cy - height / 2); var br = (X: cx + width / 2, Y: cy - height / 2);
+ var tr = (X: cx + width / 2, Y: cy + height / 2); var tl = (X: cx - width / 2, Y: cy + height / 2);
+ var path = new BoundPath(name, bl, 0, []);
+ AddEdge("Bottom", bl, br); AddEdge("Right", br, tr); AddEdge("Top", tr, tl); AddEdge("Left", tl, bl);
+ result[name] = path;
+
+ void AddEdge(string edge, (double X, double Y) start, (double X, double Y) end)
+ {
+ var matching = programs.Where(x => x.Match.Groups["owner"].Value == name && x.Match.Groups["edge"].Value == edge).ToArray();
+ if (matching.Length == 0)
+ {
+ path.Steps.Add(new(edge, "Span", $"{name}.{edge}", $"{name}.{edge}.End", [new LineArcLineSegment2D(start, end)], start, end, Heading(start, end)));
+ return;
+ }
+ if (matching.Length > 1) { diagnostics.Add($"semantic-edge-duplicate-program:{name}.{edge}"); return; }
+ var fragments = new List<SemanticEdgeFragmentIr>();
+ foreach (var step in FindPathSteps(matching[0].Body).Where(x => x.Kind is "Chamfer" or "Step" or "Notch" or "Cutback" or "Tab"))
+ {
+ var id = $"{name}.{edge}.{step.Name}";
+ var anchors = new[] { ("FromStart", SemanticEdgeAnchorKind.FromStart), ("FromEnd", SemanticEdgeAnchorKind.FromEnd), ("CenteredAt", SemanticEdgeAnchorKind.CenteredAt) }
+ .Select(x => (x.Item2, Value: Property(step.Body, x.Item1))).Where(x => x.Value is not null).ToArray();
+ if (anchors.Length != 1 || !TryMeasure(anchors[0].Value!, "mm", out var offset)) { diagnostics.Add($"semantic-edge-anchor-required:{id}"); continue; }
+ var sideText = Property(step.Body, "Side"); var side = sideText?.Equals("Left", StringComparison.OrdinalIgnoreCase) == true ? 1 : sideText?.Equals("Right", StringComparison.OrdinalIgnoreCase) == true ? -1 : 0;
+ bool Measure(string property, out double value) { value = default; var text = Property(step.Body, property); return text is not null && TryMeasure(text, "mm", out value); }
+ var anchor = new SemanticEdgeAnchorIr(anchors[0].Item1, offset); SemanticEdgeFragmentIr? fragment = null;
+ if (step.Kind == "Tab" && Measure("Width", out var tabWidth) && Measure("Extension", out var extension)) fragment = new SemanticEdgeTabIr(step.Name, id, anchor, tabWidth, extension, side, $"offset:{step.Index}");
+ else if (step.Kind == "Notch" && Measure("Width", out var notchWidth) && Measure("Depth", out var depth)) fragment = new SemanticEdgeNotchIr(step.Name, id, anchor, notchWidth, depth, side, $"offset:{step.Index}");
+ else if (step.Kind == "Step" && Measure("Width", out var stepWidth) && Measure("Rise", out var rise)) fragment = new SemanticEdgeStepIr(step.Name, id, anchor, stepWidth, rise, side, $"offset:{step.Index}");
+ else if (step.Kind == "Chamfer" && Measure("Run", out var chamferRun) && Measure("Offset", out var chamferOffset)) fragment = new SemanticEdgeChamferIr(step.Name, id, anchor, chamferRun, chamferOffset, side, $"offset:{step.Index}");
+ else if (step.Kind == "Cutback" && Measure("Run", out var cutbackRun) && Measure("Offset", out var cutbackOffset)) fragment = new SemanticEdgeCutbackIr(step.Name, id, anchor, cutbackRun, cutbackOffset, side, $"offset:{step.Index}");
+ else diagnostics.Add($"semantic-edge-fragment-properties-invalid:{id}:{step.Kind}");
+ if (fragment is not null) fragments.Add(fragment);
+ }
+ var resolution = SemanticEdgeProfileResolver.Resolve(new($"{name}.{edge}", $"{name}.{edge}", new(start.X, start.Y), new(end.X, end.Y), fragments, $"{name}.{edge}[u,v]", $"EdgeProfile {name}.{edge}"));
+ if (!resolution.IsSuccess) { diagnostics.AddRange(resolution.Diagnostics); return; }
+ foreach (var member in resolution.Profile!.OrderedMembers)
+ {
+ var first = ((LineArcLineSegment2D)member.CurveDescendants.First().Geometry).Start; var last = ((LineArcLineSegment2D)member.CurveDescendants.Last().Geometry).End;
+ path.Steps.Add(new($"{edge}.{member.Name}", member.Kind, $"{name}.{edge}.{member.Name}", $"{name}.{edge}.{member.Name}.End", member.CurveDescendants.Select(x => x.Geometry).ToArray(), first, last, Heading(first, last)));
+ }
+ }
+ }
+ foreach (var program in programs.Where(p => !result.ContainsKey(p.Match.Groups["owner"].Value)))
+ diagnostics.Add($"semantic-edge-owner-path-missing:{program.Match.Groups["owner"].Value}.{program.Match.Groups["edge"].Value}");
+ foreach (var program in programs.Where(p => result.ContainsKey(p.Match.Groups["owner"].Value) && p.Match.Groups["edge"].Value is not ("Bottom" or "Right" or "Top" or "Left")))
+ diagnostics.Add($"semantic-edge-owner-member-missing:{program.Match.Groups["owner"].Value}.{program.Match.Groups["edge"].Value}:available=Bottom,Right,Top,Left");
+ }
+
private static bool TryBindStep(string path, PathStep step, (double X, double Y) current, ref double headingDegrees, (double X, double Y) start, IReadOnlyDictionary<string, (double X, double Y)> points, out IReadOnlyList<LineArcProfileCurve2D>? curves, out (double X, double Y) endpoint, out string? diagnostic)
{
curves = null; endpoint = default; diagnostic = null;
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/SemanticEdgeProfileIr.cs b/Aetheris.Kernel.Firmament/FirmamentV2/SemanticEdgeProfileIr.cs
new file mode 100644
index 00000000..bfa30557
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/SemanticEdgeProfileIr.cs
@@ -0,0 +1,151 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text;
+using Aetheris.Kernel.Firmament.Materializer;
+
+namespace Aetheris.Kernel.Firmament.FirmamentV2;
+
+public enum SemanticEdgeAnchorKind { FromStart, FromEnd, CenteredAt }
+
+public sealed record SemanticEdgeAnchorIr(SemanticEdgeAnchorKind Kind, double Offset);
+
+public abstract record SemanticEdgeFragmentIr(
+ string Name, string StableId, string Kind, SemanticEdgeAnchorIr Anchor,
+ double Span, double Depth, int Side, string SourceSpan);
+
+public sealed record SemanticEdgeTabIr(string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Width, double Extension, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "Tab", Anchor, Width, Extension, Side, SourceSpan);
+public sealed record SemanticEdgeNotchIr(string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Width, double Depth, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "Notch", Anchor, Width, Depth, Side, SourceSpan);
+public sealed record SemanticEdgeChamferIr(string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Run, double Offset, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "Chamfer", Anchor, Run, Offset, Side, SourceSpan);
+public sealed record SemanticEdgeCutbackIr(string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Run, double Offset, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "Cutback", Anchor, Run, Offset, Side, SourceSpan);
+public sealed record SemanticEdgeStepIr(string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Width, double Rise, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "Step", Anchor, Width, Rise, Side, SourceSpan);
+public sealed record SemanticEdgeSteppedNotchIr(
+ string Name, string StableId, SemanticEdgeAnchorIr Anchor, double Width, double Depth,
+ double ShoulderDepth, double OuterChamfer, double InnerChamfer, int Side, string SourceSpan)
+ : SemanticEdgeFragmentIr(Name, StableId, "SteppedNotch", Anchor, Width, Depth, Side, SourceSpan);
+
+/// <summary>Semantic modification program for one directed, named carrier edge.</summary>
+public sealed record SemanticEdgeProfileIr(
+ string OwnerPath, string StableId, SemanticProfilePoint Start, SemanticProfilePoint End,
+ IReadOnlyList<SemanticEdgeFragmentIr> Fragments, string LocalFrame, string Provenance);
+
+public sealed record ResolvedSemanticEdgeMemberIr(
+ string Name, string StableId, string Kind, double StartU, double EndU,
+ IReadOnlyList<ResolvedSemanticProfileCurveIr> CurveDescendants, string SourceSpan,
+ bool IsGeneratedCarrier);
+
+public sealed record ResolvedSemanticEdgeProfileIr(
+ SemanticEdgeProfileIr Source, IReadOnlyList<ResolvedSemanticEdgeMemberIr> OrderedMembers,
+ string DeterministicHash, TimeSpan ResolutionTime)
+{
+ public IReadOnlyList<LineArcProfileCurve2D> ExactReplacementChain =>
+ OrderedMembers.SelectMany(member => member.CurveDescendants).Select(curve => curve.Geometry).ToArray();
+}
+
+public sealed record SemanticEdgeProfileResolution(ResolvedSemanticEdgeProfileIr? Profile, IReadOnlyList<string> Diagnostics)
+{
+ public bool IsSuccess => Profile is not null && Diagnostics.Count == 0;
+}
+
+/// <summary>
+/// Resolves independently anchored fragments in the owner's u/v frame and inserts every
+/// untouched carrier span. It is intentionally bounded to baseline-returning fragments.
+/// </summary>
+public static class SemanticEdgeProfileResolver
+{
+ private const double Tolerance = 1e-8;
+
+ public static SemanticEdgeProfileResolution Resolve(SemanticEdgeProfileIr source)
+ {
+ ArgumentNullException.ThrowIfNull(source);
+ var clock = Stopwatch.StartNew();
+ var diagnostics = new List<string>();
+ var dx = source.End.X - source.Start.X; var dy = source.End.Y - source.Start.Y;
+ var length = Math.Sqrt(dx * dx + dy * dy);
+ if (!double.IsFinite(length) || length <= Tolerance)
+ return new(null, [$"semantic-edge-owner-degenerate:{source.OwnerPath}"]);
+ var tx = dx / length; var ty = dy / length; var nx = -ty; var ny = tx;
+ var ids = new HashSet<string>(StringComparer.Ordinal);
+ var placed = new List<(SemanticEdgeFragmentIr Fragment, double Start, double End)>();
+ foreach (var fragment in source.Fragments)
+ {
+ if (!ids.Add(fragment.StableId)) { diagnostics.Add($"semantic-edge-duplicate-fragment:{fragment.StableId}"); continue; }
+ if (!double.IsFinite(fragment.Span) || fragment.Span <= Tolerance || !double.IsFinite(fragment.Depth) || fragment.Depth <= Tolerance || fragment.Side is not (-1 or 1))
+ { diagnostics.Add($"semantic-edge-invalid-fragment:{fragment.StableId}:{fragment.Kind}"); continue; }
+ if (fragment is SemanticEdgeSteppedNotchIr stepped &&
+ (!double.IsFinite(stepped.ShoulderDepth) || stepped.ShoulderDepth < -Tolerance || stepped.ShoulderDepth >= stepped.Depth - Tolerance ||
+ !double.IsFinite(stepped.OuterChamfer) || stepped.OuterChamfer < -Tolerance || !double.IsFinite(stepped.InnerChamfer) || stepped.InnerChamfer <= Tolerance ||
+ 2d * (stepped.OuterChamfer + stepped.InnerChamfer) >= stepped.Width - Tolerance || stepped.ShoulderDepth + Tolerance < stepped.OuterChamfer))
+ { diagnostics.Add($"semantic-edge-invalid-stepped-notch:{fragment.StableId}"); continue; }
+ if (!double.IsFinite(fragment.Anchor.Offset)) { diagnostics.Add($"semantic-edge-invalid-anchor:{fragment.StableId}"); continue; }
+ var start = fragment.Anchor.Kind switch
+ {
+ SemanticEdgeAnchorKind.FromStart => fragment.Anchor.Offset,
+ SemanticEdgeAnchorKind.FromEnd => length - fragment.Anchor.Offset - fragment.Span,
+ SemanticEdgeAnchorKind.CenteredAt => fragment.Anchor.Offset - fragment.Span / 2d,
+ _ => double.NaN
+ };
+ var end = start + fragment.Span;
+ if (start < -Tolerance || end > length + Tolerance)
+ { diagnostics.Add($"semantic-edge-fragment-out-of-bounds:{fragment.StableId}:{start:R}:{end:R}:owner={source.OwnerPath}:length={length:R}"); continue; }
+ placed.Add((fragment, Math.Max(0, start), Math.Min(length, end)));
+ }
+ placed.Sort((a, b) => { var c = a.Start.CompareTo(b.Start); return c != 0 ? c : StringComparer.Ordinal.Compare(a.Fragment.StableId, b.Fragment.StableId); });
+ for (var i = 1; i < placed.Count; i++)
+ if (placed[i].Start < placed[i - 1].End - Tolerance)
+ diagnostics.Add($"semantic-edge-fragment-overlap:{source.OwnerPath}:{placed[i - 1].Fragment.StableId}:{placed[i].Fragment.StableId}");
+ if (diagnostics.Count > 0) return new(null, diagnostics);
+
+ var result = new List<ResolvedSemanticEdgeMemberIr>(); var cursor = 0d; var carrier = 0;
+ foreach (var item in placed)
+ {
+ if (item.Start > cursor + Tolerance)
+ result.Add(Member($"Carrier{carrier++:D2}", $"{source.StableId}.Carrier{carrier - 1:D2}", "Carrier", cursor, item.Start,
+ [Line(cursor, 0, item.Start, 0)], "generated:untouched-carrier", true));
+ result.Add(Fragment(item.Fragment, item.Start, item.End));
+ cursor = item.End;
+ }
+ if (cursor < length - Tolerance)
+ result.Add(Member($"Carrier{carrier++:D2}", $"{source.StableId}.Carrier{carrier - 1:D2}", "Carrier", cursor, length,
+ [Line(cursor, 0, length, 0)], "generated:untouched-carrier", true));
+ clock.Stop();
+ var hashText = string.Join("|", result.SelectMany(x => x.CurveDescendants).Select(x => $"{x.StableId}:{x.Geometry}"));
+ var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(hashText))).ToLowerInvariant();
+ return new(new(source, result, hash, clock.Elapsed), []);
+
+ ResolvedSemanticEdgeMemberIr Fragment(SemanticEdgeFragmentIr f, double a, double b)
+ {
+ var v = f.Side * f.Depth;
+ IReadOnlyList<LineArcProfileCurve2D> curves = f switch
+ {
+ SemanticEdgeTabIr or SemanticEdgeNotchIr or SemanticEdgeStepIr =>
+ [Line(a, 0, a, v), Line(a, v, b, v), Line(b, v, b, 0)],
+ SemanticEdgeChamferIr or SemanticEdgeCutbackIr =>
+ [Line(a, 0, (a + b) / 2d, v), Line((a + b) / 2d, v, b, 0)],
+ SemanticEdgeSteppedNotchIr stepped => SteppedNotch(stepped, a, b),
+ _ => []
+ };
+ return Member(f.Name, f.StableId, f.Kind, a, b, curves, f.SourceSpan, false);
+ }
+ IReadOnlyList<LineArcProfileCurve2D> SteppedNotch(SemanticEdgeSteppedNotchIr f, double a, double b)
+ {
+ var side = f.Side; var points = new List<(double U, double V)> { (a, 0) };
+ if (f.OuterChamfer > Tolerance) points.Add((a + f.OuterChamfer, side * f.OuterChamfer));
+ var shoulderU = a + f.OuterChamfer; points.Add((shoulderU, side * f.ShoulderDepth));
+ points.Add((shoulderU + f.InnerChamfer, side * f.Depth));
+ points.Add((b - f.OuterChamfer - f.InnerChamfer, side * f.Depth));
+ points.Add((b - f.OuterChamfer, side * f.ShoulderDepth));
+ if (f.OuterChamfer > Tolerance) points.Add((b - f.OuterChamfer, side * f.OuterChamfer));
+ points.Add((b, 0));
+ return Enumerable.Range(0, points.Count - 1).Select(i => (LineArcProfileCurve2D)Line(points[i].U, points[i].V, points[i + 1].U, points[i + 1].V)).ToArray();
+ }
+ ResolvedSemanticEdgeMemberIr Member(string name, string id, string kind, double a, double b, IReadOnlyList<LineArcProfileCurve2D> curves, string span, bool generated) =>
+ new(name, id, kind, a, b, curves.Select((curve, ordinal) => new ResolvedSemanticProfileCurveIr($"{id}.curve{ordinal:D2}", ordinal, curve, generated ? $"generated-carrier:{source.OwnerPath}" : $"lowered-from:{id}")).ToArray(), span, generated);
+ LineArcLineSegment2D Line(double u0, double v0, double u1, double v1) => new(ToWorld(u0, v0), ToWorld(u1, v1));
+ (double X, double Y) ToWorld(double u, double v) => (source.Start.X + tx * u + nx * v, source.Start.Y + ty * u + ny * v);
+ }
+}
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs
index 756267dc..1b2b51d4 100644
--- a/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs
+++ b/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs
@@ -30,10 +30,12 @@ public sealed class SheetMetalM8Tests
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(9,result.Spec!.SemanticLayout.Patterns.Count);Assert.Single(result.Spec.SemanticLayout.Tabs);Assert.Equal(2,result.Spec.SemanticLayout.SteppedNotches!.Count);
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);
+ var paths=SheetMetalConceptPaths.Inspect(result.Spec,result.Part,result.FlatPattern).Select(x=>x.Path).ToArray();
+ Assert.Contains("Ctc03Layout.FrontConnectorRelief",paths);Assert.Contains("Flat.Ctc03Layout.FrontConnectorRelief",paths);
}
finally{if(File.Exists(isolated))File.Delete(isolated);}
}
diff --git a/Aetheris.SheetMetal.Tests/SheetMetalProfileM2Tests.cs b/Aetheris.SheetMetal.Tests/SheetMetalProfileM2Tests.cs
new file mode 100644
index 00000000..48b6d6c3
--- /dev/null
+++ b/Aetheris.SheetMetal.Tests/SheetMetalProfileM2Tests.cs
@@ -0,0 +1,47 @@
+using Aetheris.Kernel.Firmament.FirmamentV2;
+using Xunit;
+
+namespace Aetheris.SheetMetal.Tests;
+
+public sealed class SheetMetalProfileM2Tests
+{
+ [Fact]
+ public void EdgeProgram_RejectsCrossKindOverlapBeforeBrepLoweringAndNamesBothFragments()
+ {
+ const string source = """
+ Concept Struct Layout {
+ Tab MountTab { On: Lip.Outer; Center: 50mm; Width: 30mm; Extension: 5mm; }
+ SteppedNotch CableNotch {
+ On: Lip.Outer; Center: 60mm; Width: 20mm; Depth: 8mm;
+ ShoulderDepth: 4mm; OuterChamfer: 1mm; InnerChamfer: 1mm; Side: Inward;
+ }
+ }
+ SheetMetal Conflict {
+ Thickness: 1mm;
+ Base Panel { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }
+ Flange Lip { From: Panel.Rear; Height: 15mm; Angle: 90deg; Radius: 2mm; }
+ }
+ """;
+
+ var result = SheetMetalFirmament.Compile(source);
+
+ Assert.False(result.IsSuccess);
+ var diagnostic = Assert.Single(result.Diagnostics, x => x.Code == "sheetmetal-edge-profile-invalid");
+ Assert.Contains("Layout.MountTab", diagnostic.Message);
+ Assert.Contains("Layout.CableNotch", diagnostic.Message);
+ Assert.Null(result.Part);
+ }
+
+ [Fact]
+ public void AdjacentFragments_DoNotCreateZeroLengthCarrier()
+ {
+ var first = new SemanticEdgeTabIr("A", "Edge.A", new(SemanticEdgeAnchorKind.FromStart, 10), 10, 3, 1, "test");
+ var second = new SemanticEdgeNotchIr("B", "Edge.B", new(SemanticEdgeAnchorKind.FromStart, 20), 10, 3, -1, "test");
+
+ var result = SemanticEdgeProfileResolver.Resolve(new("Plate.Bottom", "Edge", new(0, 0), new(40, 0), [second, first], "u/v", "test"));
+
+ Assert.True(result.IsSuccess);
+ Assert.Equal(["Carrier", "Tab", "Notch", "Carrier"], result.Profile!.OrderedMembers.Select(x => x.Kind));
+ Assert.All(result.Profile.OrderedMembers, x => Assert.True(x.EndU - x.StartU > 1e-8));
+ }
+}
diff --git a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
index 905f5ccb..caf7cdf2 100644
--- a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs
@@ -287,32 +287,34 @@ internal static class AuthoredSheetMetalLowering
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;
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 tabs=spec.SemanticLayout.Tabs.Where(x=>x.Region.Equals(flange.Name,StringComparison.OrdinalIgnoreCase)&&x.Edge.Equals("Outer",StringComparison.OrdinalIgnoreCase)).ToArray();
+ var steppedNotches=(spec.SemanticLayout.SteppedNotches??[]).Where(x=>x.Region.Equals(flange.Name,StringComparison.OrdinalIgnoreCase)&&x.Edge.Equals("Outer",StringComparison.OrdinalIgnoreCase)).ToArray();
+ if(tabs.Length>0||steppedNotches.Length>0)
{
- var points=new List<Point3D>{tangentA,tangentB,frame.OuterB};var cursor=(edge.B-edge.A).Length;
- foreach(var tab in tabs)
+ var ownerLength=(edge.B-edge.A).Length;
+ var attachment=new SemanticEdgeProfileIr($"{flange.Name}.Outer",$"{flange.Name}.Outer",new(0,0),new(ownerLength,0),
+ tabs.Select(tab=>(SemanticEdgeFragmentIr)new SemanticEdgeTabIr(tab.Path.Split('.').Last(),tab.Path,
+ new(SemanticEdgeAnchorKind.CenteredAt,ownerLength-tab.Center),tab.Width,tab.Extension,1,"SheetMetalSemanticLayout"))
+ .Concat(steppedNotches.Select(notch=>(SemanticEdgeFragmentIr)new SemanticEdgeSteppedNotchIr(notch.Path.Split('.').Last(),notch.Path,
+ new(SemanticEdgeAnchorKind.CenteredAt,ownerLength-notch.Center),notch.Width,notch.Depth,notch.ShoulderDepth,notch.OuterChamfer,notch.InnerChamfer,notch.Side,"SheetMetalSemanticLayout"))).ToArray(),
+ "SheetRegionLocal[u=OuterB->OuterA,v=flange-outward]","Sheet Metal semantic edge attachment");
+ var composed=SemanticEdgeProfileResolver.Resolve(attachment);
+ if(!composed.IsSuccess)return Failure($"Edge attachment '{flange.Name}.Outer' failed: {string.Join("; ",composed.Diagnostics)}","sheetmetal-edge-profile-invalid");
+ var points=new List<Point3D>{tangentA,tangentB,frame.OuterB};
+ foreach(var descendant in composed.Profile!.OrderedMembers.SelectMany(member=>member.CurveDescendants))
{
- 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);
- var tabMir=new SemanticProfileIr(tab.Path,tab.Path,"SheetRegionLocal",new(right,0d),180d,
- [new SemanticProfileTabIr(tab.Path.Split('.').Last(),tab.Path,tab.Width,tab.Extension,-1,"SheetMetalSemanticLayout")],[],[],"Sheet Metal semantic Tab");
- var resolvedTab=SemanticProfileMirResolver.Resolve(tabMir);
- if(!resolvedTab.IsSuccess)return Failure($"Tab '{tab.Path}' failed semantic Profile MIR resolution: {string.Join("; ",resolvedTab.Diagnostics)}","sheetmetal-tab-profile-mir-invalid");
- foreach(var descendant in resolvedTab.Profile!.Members[0].CurveDescendants)
- {
- if(descendant.Geometry is not LineArcLineSegment2D line)return Failure($"Tab '{tab.Path}' generated a non-line descendant.","sheetmetal-tab-profile-mir-invalid");
- var mapped=frame.OuterA+axis*line.End.X+direction*line.End.Y;
- if((mapped-points[^1]).Length>1e-8)points.Add(mapped);
- }
- cursor=left;
+ if(descendant.Geometry is not LineArcLineSegment2D line)return Failure($"Edge attachment '{flange.Name}.Outer' generated a non-line descendant.","sheetmetal-edge-profile-invalid");
+ var mapped=frame.OuterB-axis*line.End.X+direction*line.End.Y;
+ if(points.Count==0||(mapped-points[^1]).Length>1e-8)points.Add(mapped);
}
- if((frame.OuterA-points[^1]).Length>1e-8)points.Add(frame.OuterA);boundary=points;
+ boundary=points;
+ foreach(var fragment in composed.Profile.OrderedMembers.Where(member=>!member.IsGeneratedCarrier))
+ correspondence.Add(new(fragment.StableId,"EdgeFragment",fragment.StableId,$"flat-{fragment.StableId}"));
}
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+tabs.Sum(x=>x.Width*x.Extension), source, evidence));
+ var fragmentArea=tabs.Sum(x=>x.Width*x.Extension)-steppedNotches.Sum(x=>x.Width*x.Depth);
+ regions.Add(new(flangeId, SheetRegionKind.Planar, Developable("Authored planar flange."), plane, null, boundary, (edge.B-edge.A).Length * flange.Length+fragmentArea, 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/SheetMetalConceptPaths.cs b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
index 99afe34b..b0bf6fa1 100644
--- a/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
+++ b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs
@@ -43,6 +43,8 @@ public static class SheetMetalConceptPaths
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 notch in spec.SemanticLayout.SteppedNotches??[])
+ Add(notch.Path,"SheetSteppedNotch",notch.Path,notch.Region,$"flat-{notch.Region}","semantic stepped edge removal","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)
diff --git a/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs b/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs
index 527521fd..22ff307a 100644
--- a/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs
+++ b/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs
@@ -8,6 +8,9 @@ public enum SheetMetalSemanticConstraintKind { RequiredMembers, EqualSize, Equal
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 SheetMetalSemanticSteppedNotch(
+ string Path,string Region,string Edge,double Center,double Width,double Depth,
+ double ShoulderDepth,double OuterChamfer,double InnerChamfer,int Side);
public sealed record SheetMetalSemanticPattern(
string Path,string Name,string Region,SheetFeatureKind FeatureKind,int Count,double CenterX,double CenterY,
@@ -18,7 +21,8 @@ public sealed record SheetMetalSemanticConstraint(
public sealed record SheetMetalSemanticLayout(
IReadOnlyList<string> Structs,IReadOnlyList<SheetMetalSemanticDatum> Datums,IReadOnlyList<SheetMetalSemanticTab> Tabs,
- IReadOnlyList<SheetMetalSemanticPattern> Patterns,IReadOnlyList<SheetMetalSemanticConstraint> Constraints)
+ IReadOnlyList<SheetMetalSemanticPattern> Patterns,IReadOnlyList<SheetMetalSemanticConstraint> Constraints,
+ IReadOnlyList<SheetMetalSemanticSteppedNotch>? SteppedNotches = null)
{
public static SheetMetalSemanticLayout Empty { get; } = new([],[],[],[],[]);
}
@@ -49,6 +53,7 @@ internal static class SheetMetalSemanticLayoutParser
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 steppedNotches=new List<SheetMetalSemanticSteppedNotch>();
var patterns=new List<SheetMetalSemanticPattern>();
var generated=new List<AuthoredSheetCutSpec>();
var constraints=new List<SheetMetalSemanticConstraint>();
@@ -74,6 +79,20 @@ internal static class SheetMetalSemanticLayoutParser
tabs.Add(new(Path(block),match.Groups["region"].Value,match.Groups["edge"].Value,center,width,extension));
}
+ foreach(var block in Blocks(source,"SteppedNotch",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-edge-fragment-owner",$"SteppedNotch '{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,"Depth",out var depth)||
+ !Scalar(block.Body,"ShoulderDepth",out var shoulder)||!Scalar(block.Body,"OuterChamfer",out var outerChamfer)||!Scalar(block.Body,"InnerChamfer",out var innerChamfer))
+ return Fail("sheetmetal-edge-fragment-properties",$"SteppedNotch '{Path(block)}' requires Center, Width, Depth, ShoulderDepth, OuterChamfer, and InnerChamfer.");
+ var sideToken=Token(block.Body,"Side");var side=sideToken?.Equals("Outward",StringComparison.OrdinalIgnoreCase)==true?1:sideToken?.Equals("Inward",StringComparison.OrdinalIgnoreCase)==true?-1:0;
+ if(width<=0||depth<=0||shoulder<0||shoulder>=depth||outerChamfer<0||innerChamfer<=0||2*(outerChamfer+innerChamfer)>=width||side==0)
+ return Fail("sheetmetal-edge-fragment-invalid",$"SteppedNotch '{Path(block)}' has impossible dimensions or Side (use Inward/Outward).");
+ if(center-width/2< -1e-8||center+width/2>size.Width+1e-8)return Fail("sheetmetal-edge-fragment-outside",$"SteppedNotch '{Path(block)}' lies outside '{on}'.");
+ steppedNotches.Add(new(Path(block),match.Groups["region"].Value,match.Groups["edge"].Value,center,width,depth,shoulder,outerChamfer,innerChamfer,side));
+ }
+
foreach(var block in Blocks(source,"Pattern",structs))
{
var path=Path(block);var region=Token(block.Body,"On");
@@ -151,7 +170,7 @@ internal static class SheetMetalSemanticLayoutParser
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);
+ 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(),steppedNotches.OrderBy(x=>x.Path,StringComparer.Ordinal).ToArray()),generated,diagnostics);
SheetMetalSemanticLayoutParseResult Fail(string code,string message)=>new(false,SheetMetalSemanticLayout.Empty,[],[new(code,SheetMetalDiagnosticSeverity.Error,message)]);
}
diff --git a/docs/language/semantic-profile-edge-composition-m2.md b/docs/language/semantic-profile-edge-composition-m2.md
new file mode 100644
index 00000000..02fd1cf8
--- /dev/null
+++ b/docs/language/semantic-profile-edge-composition-m2.md
@@ -0,0 +1,169 @@
+# Semantic Profile edge composition M2 report
+
+## Verdict
+
+**Meaningful progression.** Generic single-edge attachment is implemented and
+used by ordinary Profiles and Sheet Metal. It materially improves CTC-03's
+front/rear mounting-flange outlines. CTC-03 remains `NeedsReview` because
+corner-consuming wall tapers and right-wall transitions span two owning edges;
+M2 deliberately does not disguise those as single-edge features.
+
+## Why M1 stopped short
+
+M1 resolves semantic members with a moving cursor. A member knows the endpoint
+of the preceding member, but has no independent interval on a named owner.
+Consequently authors had to state every carrier segment, manually order
+features, and manually transform them into the profile frame. M2 adds the
+missing interval/owner layer:
+
+```text
+named directed edge + independently anchored fragments
+ -> validate bounds and conflicts
+ -> sort by resolved u interval
+ -> generate CarrierNN gaps
+ -> lower each semantic member one-to-many
+ -> exact replacement chain
+ -> ResolvedProfile2D / PlanarContour2
+```
+
+The implementation types are `SemanticEdgeProfileIr`,
+`SemanticEdgeFragmentIr` and its typed records, `SemanticEdgeAnchorIr`,
+`ResolvedSemanticEdgeMemberIr`, `ResolvedSemanticEdgeProfileIr`, and
+`SemanticEdgeProfileResolver`.
+
+## Authoring and local frame
+
+```firmament
+Concept Struct Layout On XY {
+ Rect2 PlateBase { Center: [0mm, 0mm]; Size: [100mm, 60mm] }
+ EdgeProfile PlateBase.Bottom {
+ Notch CableNotch { FromStart: 18mm; Width: 8mm; Depth: 4mm; Side: Left }
+ Tab MountTab { CenteredAt: 50mm; Width: 12mm; Extension: 6mm; Side: Right }
+ }
+}
+Profile Plate From PlateBase
+```
+
+`u=0` is the directed owner start and `u=length` its end. Positive `v` is
+left of the owner tangent for ordinary Profiles. Exactly one of `FromStart`,
+`FromEnd`, or `CenteredAt` is required. Anchors resolve to occupied intervals;
+source order is not geometry order. Equal endpoints are allowed, zero-length
+carriers are omitted, and overlaps name both fragment paths.
+
+The bounded generic fragment records are `Tab`, `Notch`, `Step`, `Chamfer`,
+`Cutback`, and `SteppedNotch`. Tabs/notches/steps lower to three lines,
+chamfers/cutbacks to two, and stepped notches to five or seven. These operations
+return to the carrier baseline. Arc transition remains an M1 cursor member and
+is not yet an independently attached fragment.
+
+Generated paths look like:
+
+```text
+Plate.Bottom.Carrier00
+Plate.Bottom.CableNotch
+Plate.Bottom.MountTab
+Plate.Bottom.MountTab.Curve00
+```
+
+Template expansion runs before edge binding. A generic Template test varies
+plate/tab dimensions and proves that `Plate.Bottom.MountTab` survives
+specialization. The non-Sheet-Metal dogfood fixture is
+`fixtures/FirmamentV2/Canonical/valid/profile-edge-attachment-plate.firmament`;
+it validates, extrudes, exports STEP, and reimports as one enclosed manifold.
+
+## Diagnostics exercised
+
+- `semantic-edge-fragment-overlap:<owner>:<first>:<second>`
+- `semantic-edge-fragment-out-of-bounds:<fragment>:...`
+- `semantic-edge-invalid-fragment:<fragment>:<kind>`
+- `semantic-edge-invalid-stepped-notch:<fragment>`
+- `semantic-edge-duplicate-fragment:<fragment>`
+- `semantic-edge-anchor-required:<fragment>`
+- `semantic-edge-owner-path-missing:<path>`
+- `semantic-edge-owner-member-missing:<path>:available=...`
+
+Tests also cover adjacency, declaration reordering, owner-length changes,
+stable hashes, one-to-many descendants, and cross-kind Sheet Metal conflicts
+before BRep construction.
+
+## Sheet Metal and correspondence
+
+Authored Sheet Metal outer-edge programs now call the generic resolver; the M8
+service tab no longer owns its own cursor/span assembly loop. Sheet Metal maps
+the resolved local chain into the region plane, carries fragment IDs in
+`SheetMetalCorrespondence`, and exposes formed and `Flat.*` Concept Paths.
+DFM continues to use semantic feature/region IDs. Full curve-level provenance
+inside `SheetRegionIr.Boundary3D` is not yet represented because that record is
+still a point loop; exact Profile/PlanarContour descendants do preserve it.
+
+## CTC-03
+
+The source-independent construction adds two semantic programs:
+
+- `Ctc03Layout.FrontConnectorRelief`: symmetric five-curve stepped notch,
+ 127 mm wide, 31.75 mm deep, 25.4 mm shoulder, 6.35 mm inner chamfer.
+- `Ctc03Layout.RearConnectorRelief`: symmetric seven-curve stepped notch,
+ 139.7 mm wide with 6.35 mm outer and inner chamfers.
+
+The source STEP was used to recover dimensions and only for post-generation
+comparison. The final `.firmament` source has no STEP path, face ID, edge ID,
+or recovered polygon and still compiles from an isolated temporary copy.
+
+| Measure | M8/Profile-M1 | Profile-M2 |
+|---|---:|---:|
+| formed source -> generated RMS | 19.462739 | 10.614040 mm |
+| formed source -> generated p95 | 52.484591 | 19.071261 mm |
+| formed source -> generated max | 56.694590 | 52.816066 mm |
+| formed generated -> source RMS | 6.660487 | 6.750457 mm |
+| formed generated -> source p95 | 12.735724 | 8.310053 mm |
+| formed generated -> source max | 19.071261 | 19.071261 mm |
+| flat width residual | 0.002447 | 0.002447 mm |
+| flat height residual | 12.707820 | 0.007820 mm |
+| flat contour RMS | 12.376320 | 12.038486 mm |
+| flat p95 / max | 19.047460 / 19.047460 | 19.047460 / 19.047460 mm |
+
+All seven bends and all 17 openings remain comparison passes. Formed/flat STEP
+export and reimport remain manifold. The two fragment paths appear in both
+formed and flat inspection. Front/rear central outline composition is now easy;
+the remaining anonymous-curve pressure occurs at left/right wall ends and
+mounting-flange corners, where one manufacturing corner consumes endpoints on
+two adjacent owners.
+
+## Performance, determinism, and validation
+
+One measured CTC run: parse 26.5 ms, semantic resolve 16.1 ms, formed lower
+73.3 ms, authored flat lower 58.7 ms, flatten 7.0 ms. Two independent runs
+produced flat hash
+`e3ec913e24f65d220839bbdbfa2d909dd8bdeeaed87ecc9ccfc6c1be7a1d297c`.
+
+Validation performed:
+
+- `dotnet restore Aetheris.slnx`: pass.
+- `dotnet build Aetheris.slnx --no-restore`: pass, zero warnings/errors.
+- Profile-M2 tests: 9/9 pass.
+- Sheet Metal Profile-M2 tests: 2/2 pass.
+- Firmament suite: 1148/1148 pass after final rebuild.
+- Sheet Metal suite: 60/60 pass.
+- CLI validation/build/STEP reimport: pass; enclosed manifold.
+- Full solution run: all feature suites pass; Kernel.Core had two unrelated
+ timing assertions fail under parallel load. Both passed immediately in
+ isolated reruns; a later full Kernel.Core run exposed a different timing
+ assertion, which also passed in isolation. This is recorded as existing
+ performance-test nondeterminism, not hidden as an all-green full run.
+- `git diff --check`: no errors (repository line-ending warnings only).
+
+## Architecture answer and debt
+
+For bounded, baseline-returning modifications, Firmament can now attach tabs,
+steps, chamfers, notches, cutbacks, and a repeated stepped-notch shape to a
+meaningful named Profile edge while the compiler owns local coordinates,
+ordering, carrier spans, exact curves, paths, and deterministic hashes. That
+removes the need to redraw the full Profile for those features, and fragment
+identity survives into formed/flat Sheet Metal inspection and correspondence.
+
+Code quality is an acceptable localized prototype. The generic resolver and IR
+are clean; the Profile frontend remains the intentionally bounded regex/block
+adapter documented since M1. The single largest blocker is now explicit
+cross-edge corner ownership: one bounded corner program must be allowed to
+consume both adjacent carrier endpoints and publish the resulting shared
+endpoint without introducing a general sketch or Boolean solver.
diff --git a/docs/language/semantic-profiles.md b/docs/language/semantic-profiles.md
index 053e1498..c492908d 100644
--- a/docs/language/semantic-profiles.md
+++ b/docs/language/semantic-profiles.md
@@ -55,3 +55,50 @@ Firmament Concept Path / Profile
Each exact descendant carries its semantic member stable ID as provenance. Splitting or offsetting a `PlanarContour2` preserves that ancestry. Stable IDs and contour hashes depend only on normalized semantic input and resolved exact geometry, not BRep edge numbering.
This is intentionally not a general-purpose sketch solver. Relationships are admitted only when their resolution is direct and bounded. M1 includes required-member, equal-size, and paired mirror validation in the MIR API.
+
+## Attached edge profiles
+
+`EdgeProfile` modifies one directed semantic edge without restating its untouched
+parts. The owner path supplies the local frame: `u` runs from the edge start to
+its end, and positive `v` is the left side of that direction. `Side: Left` and
+`Side: Right` select positive and negative `v` respectively.
+
+```firmament
+Rect2 PlateBase { Center: [0mm, 0mm]; Size: [100mm, 60mm] }
+EdgeProfile PlateBase.Bottom {
+ Notch CableNotch { FromStart: 18mm; Width: 8mm; Depth: 4mm; Side: Left }
+ Tab MountTab { CenteredAt: 50mm; Width: 12mm; Extension: 6mm; Side: Right }
+}
+Profile Plate From PlateBase
+Extrude Solid { Profile: Plate; From: 0mm; To: 3mm }
+```
+
+Each fragment must have exactly one anchor: `FromStart`, `FromEnd`, or
+`CenteredAt`. The values are distances in the owner's local `u` coordinate.
+Resolution sorts by the resulting interval, rejects overlaps and out-of-bounds
+intervals with both semantic paths in the diagnostic, and inserts non-zero
+`CarrierNN` members for every gap. Declaration order therefore has no geometric
+effect when anchors fully determine placement.
+
+The current bounded attached set is `Tab`, `Notch`, `Step`, `Chamfer`,
+`Cutback`, and the multi-transition `SteppedNotch` used by Sheet Metal mounting
+flanges. Tabs, notches, and bounded steps lower to three lines; chamfers and
+cutbacks lower to two; a `SteppedNotch` lowers to five or seven lines depending
+on whether it has an outer chamfer. All return to the owning carrier baseline, which keeps
+replacement continuous and makes adjacency unambiguous. Endpoint-consuming
+corner fragments and tangent arc attachments are not yet admitted.
+
+Identity remains hierarchical through lowering:
+
+```text
+Plate.Bottom
+ Carrier00 generated untouched span
+ CableNotch authored semantic fragment -> 3 curves
+ Carrier01 generated untouched span
+ MountTab authored semantic fragment -> 3 curves
+ Carrier02 generated untouched span
+```
+
+`Plate.Bottom.MountTab` and its `Curve00` descendants are normal Concept Path
+members. The owning edge, authored fragments, and generated carriers all retain
+stable provenance in `ResolvedProfile2D` and `PlanarContour2`.
diff --git a/docs/modules/sheetmetal/artifacts/m8/README.md b/docs/modules/sheetmetal/artifacts/m8/README.md
index 142806cc..473f1f29 100644
--- a/docs/modules/sheetmetal/artifacts/m8/README.md
+++ b/docs/modules/sheetmetal/artifacts/m8/README.md
@@ -4,7 +4,7 @@
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.
+Profile-M2 now reconstructs the complex central front and rear mounting-flange free edges through generic semantic edge attachment. It is still not a full CTC-03 reconstruction: endpoint corner ownership, left-wall tapered ends, and right-wall attachment cutbacks remain simplified. The comparison remains `NeedsReview`, but source-to-generated formed RMS improves from 19.4627 to 10.6140 mm, p95 from 52.4846 to 19.0713 mm, and flat height residual from 12.7078 to 0.00782 mm. The isolated next blocker is cross-edge corner composition, not single-edge fragment placement or hole recognition.
## Delivered mechanism
@@ -45,4 +45,4 @@ The non-CTC generalization fixture is [`m8-semantic-panel.firmament`](../../../.
**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.
+**Largest remaining blocker?** Bounded corner programs that may consume both an owning edge endpoint and the adjacent edge endpoint while preserving one explicit corner owner. Single-edge fragments now compose deterministically and retain correspondence; the remaining CTC wall tapers and mounting-flange end chamfers cross that seam.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md
index 5235f2a1..b67179e3 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-comparison.md
@@ -1,4 +1,4 @@
-# CTC-03 formed and flat comparison
+# CTC-03 formed and flat comparison after Profile-M2 edge composition
Command:
@@ -13,12 +13,12 @@ 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 |
+| Source → intent RMS / p95 / max | 10.6140 / 19.0713 / 52.8161 mm |
+| Intent → source RMS / p95 / max | 6.75046 / 8.31005 / 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.
+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. Profile-M2 reconstructs the front and rear mounting-flange free-edge programs as semantic `SteppedNotch` fragments. Against the M8/Profile-M1 baseline, source-to-intent RMS fell from 19.4627 to 10.6140 mm and p95 from 52.4846 to 19.0713 mm. Remaining maximum error is localized to wall-end/corner topology.
## Flat
@@ -26,15 +26,15 @@ Bend axis residual is at most 0.002542 mm; bend-axis angle residual is zero; ben
|---|---:|
| 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 |
+| Height residual | 0.00781965 mm |
+| Outer-contour RMS / p95 / max | 12.0385 / 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.
+The generated blank is internally valid, connected, non-self-intersecting, and exact on the authored model. Mounting-flange reconstruction removes essentially all height error (12.7078 to 0.00782 mm). It is not yet tolerance-equivalent because the remaining wall corner/end transitions require cross-edge corner ownership rather than a baseline-returning single-edge fragment.
## Independent regeneration and reimport
@@ -42,7 +42,7 @@ The final source reads no STEP path or recovered topology identifiers. Tests cop
| 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 |
+| Formed | 1 / 1 | 113 | 260 | 166 | 84 plane, 29 cylinder |
+| Flat | 1 / 1 | 112 | 330 | 220 | 82 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.
+DFM is `Pass`. Restoring the semantic mounting-flange outlines raises the two front mounting-hole edge clearances from the simplified 0.7849 mm result to 5.2324 mm without moving the source-matched holes.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md b/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md
index a964c7a3..3f868572 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-feature-inventory.md
@@ -17,7 +17,7 @@ Inventory is from a fresh CLI recognition of `testdata/step242/nist/CTC/nist_ctc
| 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 |
+| Front/rear mounting-flange stepped/chamfered free-edge reliefs | 2 | boundary evidence | 2 semantic `SteppedNotch` programs | Pass for central edge programs; endpoint corner chamfers remain |
| Right-wall service attachment cutbacks | present | boundary evidence | partial-span attachment only | Missing exact trim parity |
## Opening detail
@@ -30,7 +30,7 @@ Nothing in the recognized opening inventory is absent. The remaining absent geom
- base/wall corner cutbacks and stepped transitions;
- front and rear wall end bands;
-- the 12–14 segment front/rear mounting-flange boundary shapes;
+- mounting-flange endpoint corner chamfers (central 5/7-curve free-edge programs are regenerated);
- left-wall tapered ends;
- right-wall chamfers and service-attachment cutbacks.
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament b/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament
index 6493aa2f..fad55735 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-final.firmament
@@ -27,6 +27,30 @@ Concept Struct Ctc03Layout {
Extension: 12.7mm;
}
+ // Source free-edge programs. Both are symmetric bounded removals from the
+ // mounting-flange outer carrier; carrier spans are generated by the compiler.
+ SteppedNotch FrontConnectorRelief {
+ On: FrontMountingFlange.Outer;
+ Center: 120.65mm;
+ Width: 127mm;
+ Depth: 31.75mm;
+ ShoulderDepth: 25.4mm;
+ OuterChamfer: 0mm;
+ InnerChamfer: 6.35mm;
+ Side: Inward;
+ }
+
+ SteppedNotch RearConnectorRelief {
+ On: RearMountingFlange.Outer;
+ Center: 120.65mm;
+ Width: 139.7mm;
+ Depth: 31.75mm;
+ ShoulderDepth: 25.4mm;
+ OuterChamfer: 6.35mm;
+ InnerChamfer: 6.35mm;
+ Side: Inward;
+ }
+
// Four source-PMI Ø0.625 in holes at equal 1.75 in pitch.
Pattern BaseFastenerPattern {
On: MainDeck;
@@ -117,7 +141,7 @@ SheetMetal Ctc03 : Ctc03ManufacturedIntent {
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 FrontMountingFlange { From: FrontWall.Outer; Length: 43.47972mm; 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
index c1d58050..d2ef1b0c 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.step
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.step
@@ -10,3387 +10,3849 @@ DATA;
#3=DIRECTION($,(1,0,0));
#4=AXIS2_PLACEMENT_3D($,#1,#2,#3);
#5=PLANE($,#4);
-#6=CARTESIAN_POINT($,(402.051790441049,248.351340352839,0));
+#6=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
#7=VERTEX_POINT($,#6);
-#8=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#8=CARTESIAN_POINT($,(402.051790441049,273.751340352839,0));
#9=VERTEX_POINT($,#8);
-#10=CARTESIAN_POINT($,(402.051790441049,248.351340352839,0));
+#10=CARTESIAN_POINT($,(402.051790441049,261.051340352839,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));
+#16=CARTESIAN_POINT($,(414.751790441049,273.751340352839,-0));
#17=VERTEX_POINT($,#16);
-#18=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#18=CARTESIAN_POINT($,(402.051790441049,273.751340352839,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));
+#24=CARTESIAN_POINT($,(414.751790441049,375.351340352839,-0));
#25=VERTEX_POINT($,#24);
-#26=CARTESIAN_POINT($,(414.751790441049,261.051340352839,-0));
+#26=CARTESIAN_POINT($,(414.751790441049,273.751340352839,-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));
+#32=CARTESIAN_POINT($,(402.051790441049,375.351340352839,0));
#33=VERTEX_POINT($,#32);
-#34=CARTESIAN_POINT($,(414.751790441049,362.651340352839,-0));
+#34=CARTESIAN_POINT($,(414.751790441049,375.351340352839,-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));
+#40=CARTESIAN_POINT($,(402.051790441049,388.051340352839,-0));
#41=VERTEX_POINT($,#40);
-#42=CARTESIAN_POINT($,(402.051790441049,362.651340352839,0));
+#42=CARTESIAN_POINT($,(402.051790441049,375.351340352839,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));
+#48=CARTESIAN_POINT($,(353.537790441049,388.051340352839,0));
#49=VERTEX_POINT($,#48);
-#50=CARTESIAN_POINT($,(402.051790441049,375.351340352839,-0));
+#50=CARTESIAN_POINT($,(402.051790441049,388.051340352839,-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));
+#56=CARTESIAN_POINT($,(347.802420352839,388.051340352839,0));
#57=VERTEX_POINT($,#56);
-#58=CARTESIAN_POINT($,(353.537790441049,375.351340352839,0));
+#58=CARTESIAN_POINT($,(353.537790441049,388.051340352839,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));
+#64=CARTESIAN_POINT($,(347.802420352839,498.058740352839,-0));
#65=VERTEX_POINT($,#64);
-#66=CARTESIAN_POINT($,(347.802420352839,375.351340352839,0));
+#66=CARTESIAN_POINT($,(347.802420352839,388.051340352839,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));
+#72=CARTESIAN_POINT($,(318.691480352839,498.058740352839,0));
#73=VERTEX_POINT($,#72);
-#74=CARTESIAN_POINT($,(347.802420352839,485.358740352839,-0));
+#74=CARTESIAN_POINT($,(347.802420352839,498.058740352839,-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));
+#80=CARTESIAN_POINT($,(307.22074017642,498.058740352839,0));
#81=VERTEX_POINT($,#80);
-#82=CARTESIAN_POINT($,(318.691480352839,485.358740352839,0));
+#82=CARTESIAN_POINT($,(318.691480352839,498.058740352839,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));
+#88=CARTESIAN_POINT($,(307.22074017642,504.966701934679,-0));
#89=VERTEX_POINT($,#88);
-#90=CARTESIAN_POINT($,(307.22074017642,485.35874035284,0));
+#90=CARTESIAN_POINT($,(307.22074017642,498.058740352839,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));
+#96=CARTESIAN_POINT($,(302.057092906805,499.803054665064,0));
#97=VERTEX_POINT($,#96);
-#98=CARTESIAN_POINT($,(307.22074017642,492.266701934679,-0));
+#98=CARTESIAN_POINT($,(307.22074017642,504.966701934679,-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));
+#104=CARTESIAN_POINT($,(300.710054488645,501.150093083225,0));
#105=VERTEX_POINT($,#104);
-#106=CARTESIAN_POINT($,(302.057092906805,487.103054665064,0));
+#106=CARTESIAN_POINT($,(302.057092906805,499.803054665064,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));
+#112=CARTESIAN_POINT($,(305.873701758259,506.313740352839,-0));
#113=VERTEX_POINT($,#112);
-#114=CARTESIAN_POINT($,(300.710054488645,488.450093083225,0));
-#115=DIRECTION($,(0.707106781186544,0.707106781186551,0));
+#114=CARTESIAN_POINT($,(300.710054488645,501.150093083225,0));
+#115=DIRECTION($,(0.707106781186548,0.707106781186548,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));
+#120=CARTESIAN_POINT($,(298.96574017642,506.313740352839,0));
#121=VERTEX_POINT($,#120);
-#122=CARTESIAN_POINT($,(305.873701758259,493.613740352839,-0));
+#122=CARTESIAN_POINT($,(305.873701758259,506.313740352839,-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));
+#128=CARTESIAN_POINT($,(298.96574017642,517.784480529259,0));
#129=VERTEX_POINT($,#128);
-#130=CARTESIAN_POINT($,(298.96574017642,493.613740352839,0));
+#130=CARTESIAN_POINT($,(298.96574017642,506.313740352839,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));
+#136=CARTESIAN_POINT($,(298.96574017642,579.377020529259,0));
#137=VERTEX_POINT($,#136);
-#138=CARTESIAN_POINT($,(298.96574017642,505.084480529259,0));
+#138=CARTESIAN_POINT($,(298.96574017642,517.784480529259,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));
+#144=CARTESIAN_POINT($,(298.96574017642,590.847760705679,0));
#145=VERTEX_POINT($,#144);
-#146=CARTESIAN_POINT($,(298.96574017642,566.677020529259,0));
+#146=CARTESIAN_POINT($,(298.96574017642,579.377020529259,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));
+#152=CARTESIAN_POINT($,(298.96574017642,635.297760705679,-0));
#153=VERTEX_POINT($,#152);
-#154=CARTESIAN_POINT($,(298.96574017642,578.147760705679,0));
+#154=CARTESIAN_POINT($,(298.96574017642,590.847760705679,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));
+#160=CARTESIAN_POINT($,(248.16574017642,635.297760705679,-0));
#161=VERTEX_POINT($,#160);
-#162=CARTESIAN_POINT($,(298.96574017642,622.597760705679,-0));
+#162=CARTESIAN_POINT($,(298.96574017642,635.297760705679,-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));
+#168=CARTESIAN_POINT($,(241.81574017642,628.947760705679,-0));
#169=VERTEX_POINT($,#168);
-#170=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,-0));
-#171=DIRECTION($,(0,-1,0));
+#170=CARTESIAN_POINT($,(248.16574017642,635.297760705679,-0));
+#171=DIRECTION($,(-0.707106781186546,-0.707106781186549,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));
+#176=CARTESIAN_POINT($,(241.81574017642,609.897760705679,0));
#177=VERTEX_POINT($,#176);
-#178=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,0));
+#178=CARTESIAN_POINT($,(241.81574017642,628.947760705679,-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));
+#184=CARTESIAN_POINT($,(235.46574017642,603.547760705679,0));
#185=VERTEX_POINT($,#184);
-#186=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,0));
-#187=DIRECTION($,(0,-1,0));
+#186=CARTESIAN_POINT($,(241.81574017642,609.897760705679,0));
+#187=DIRECTION($,(-0.707106781186546,-0.707106781186549,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));
+#192=CARTESIAN_POINT($,(121.16574017642,603.547760705679,0));
#193=VERTEX_POINT($,#192);
-#194=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,0));
-#195=DIRECTION($,(0,-1,0));
+#194=CARTESIAN_POINT($,(235.46574017642,603.547760705679,0));
+#195=DIRECTION($,(-1,0,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));
+#200=CARTESIAN_POINT($,(114.81574017642,609.897760705679,0));
#201=VERTEX_POINT($,#200);
-#202=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,0));
-#203=DIRECTION($,(-1,0,0));
+#202=CARTESIAN_POINT($,(121.16574017642,603.547760705679,0));
+#203=DIRECTION($,(-0.707106781186546,0.707106781186549,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));
+#208=CARTESIAN_POINT($,(114.81574017642,628.947760705679,-0));
#209=VERTEX_POINT($,#208);
-#210=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,-0));
-#211=DIRECTION($,(0.707106781186545,-0.70710678118655,0));
+#210=CARTESIAN_POINT($,(114.81574017642,609.897760705679,0));
+#211=DIRECTION($,(0,1,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));
+#216=CARTESIAN_POINT($,(108.46574017642,635.297760705679,-0));
#217=VERTEX_POINT($,#216);
-#218=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,0));
-#219=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));
+#218=CARTESIAN_POINT($,(114.81574017642,628.947760705679,-0));
+#219=DIRECTION($,(-0.707106781186546,0.707106781186549,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));
+#224=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,-0));
#225=VERTEX_POINT($,#224);
-#226=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,0));
-#227=DIRECTION($,(-0.707106781186545,0.70710678118655,0));
+#226=CARTESIAN_POINT($,(108.46574017642,635.297760705679,-0));
+#227=DIRECTION($,(-1,0,0));
#228=VECTOR($,#227,1);
#229=LINE($,#226,#228);
#230=EDGE_CURVE($,#217,#225,#229,.T.);
#231=ORIENTED_EDGE($,$,$,#230,.T.);
-#232=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
+#232=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,0));
#233=VERTEX_POINT($,#232);
-#234=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,-0));
+#234=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,-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));
+#240=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,0));
#241=VERTEX_POINT($,#240);
-#242=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,0));
-#243=DIRECTION($,(-1,0,0));
+#242=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,0));
+#243=DIRECTION($,(0,-1,0));
#244=VECTOR($,#243,1);
#245=LINE($,#242,#244);
#246=EDGE_CURVE($,#233,#241,#245,.T.);
#247=ORIENTED_EDGE($,$,$,#246,.T.);
-#248=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#248=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,0));
#249=VERTEX_POINT($,#248);
-#250=CARTESIAN_POINT($,(54.45,485.35874035284,0));
-#251=DIRECTION($,(-1,0,0));
+#250=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,0));
+#251=DIRECTION($,(0,-1,0));
#252=VECTOR($,#251,1);
#253=LINE($,#250,#252);
#254=EDGE_CURVE($,#241,#249,#253,.T.);
#255=ORIENTED_EDGE($,$,$,#254,.T.);
-#256=CARTESIAN_POINT($,(10,133.568740352839,-0));
+#256=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,0));
#257=VERTEX_POINT($,#256);
-#258=CARTESIAN_POINT($,(10,485.35874035284,-0));
+#258=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,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));
+#264=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,-0));
#265=VERTEX_POINT($,#264);
-#266=CARTESIAN_POINT($,(10,133.568740352839,-0));
-#267=DIRECTION($,(1,0,0));
+#266=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,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));
+#272=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,0));
#273=VERTEX_POINT($,#272);
-#274=CARTESIAN_POINT($,(54.45,133.568740352839,0));
-#275=DIRECTION($,(1,0,0));
+#274=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,-0));
+#275=DIRECTION($,(0.707106781186549,-0.707106781186547,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));
+#280=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,0));
#281=VERTEX_POINT($,#280);
-#282=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,0));
-#283=DIRECTION($,(0,-1,0));
+#282=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,0));
+#283=DIRECTION($,(-0.707106781186536,-0.707106781186559,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));
+#288=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,-0));
#289=VERTEX_POINT($,#288);
-#290=CARTESIAN_POINT($,(65.9207401764197,126.660778771,-0));
-#291=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#290=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,0));
+#291=DIRECTION($,(-0.707106781186549,0.707106781186547,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));
+#296=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,0));
#297=VERTEX_POINT($,#296);
-#298=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,0));
-#299=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#298=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,-0));
+#299=DIRECTION($,(0,-1,0));
#300=VECTOR($,#299,1);
#301=LINE($,#298,#300);
#302=EDGE_CURVE($,#289,#297,#301,.T.);
#303=ORIENTED_EDGE($,$,$,#302,.T.);
-#304=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));
+#304=CARTESIAN_POINT($,(54.45,498.058740352839,0));
#305=VERTEX_POINT($,#304);
-#306=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,0));
-#307=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#306=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,0));
+#307=DIRECTION($,(-1,0,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));
+#312=CARTESIAN_POINT($,(10,498.058740352839,-0));
#313=VERTEX_POINT($,#312);
-#314=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,-0));
-#315=DIRECTION($,(1,0,0));
+#314=CARTESIAN_POINT($,(54.45,498.058740352839,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));
+#320=CARTESIAN_POINT($,(10,146.268740352839,-0));
#321=VERTEX_POINT($,#320);
-#322=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,0));
+#322=CARTESIAN_POINT($,(10,498.058740352839,-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));
+#328=CARTESIAN_POINT($,(54.45,146.268740352839,0));
#329=VERTEX_POINT($,#328);
-#330=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,0));
-#331=DIRECTION($,(0,-1,0));
+#330=CARTESIAN_POINT($,(10,146.268740352839,-0));
+#331=DIRECTION($,(1,0,0));
#332=VECTOR($,#331,1);
#333=LINE($,#330,#332);
#334=EDGE_CURVE($,#321,#329,#333,.T.);
#335=ORIENTED_EDGE($,$,$,#334,.T.);
-#336=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#336=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,0));
#337=VERTEX_POINT($,#336);
-#338=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,0));
-#339=DIRECTION($,(0,-1,0));
+#338=CARTESIAN_POINT($,(54.45,146.268740352839,0));
+#339=DIRECTION($,(1,0,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));
+#344=CARTESIAN_POINT($,(65.9207401764197,139.360778771,-0));
#345=VERTEX_POINT($,#344);
-#346=CARTESIAN_POINT($,(74.1757401764197,40.77972,0));
+#346=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,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));
+#352=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,0));
#353=VERTEX_POINT($,#352);
-#354=CARTESIAN_POINT($,(74.1757401764197,10,-0));
-#355=DIRECTION($,(1,0,0));
+#354=CARTESIAN_POINT($,(65.9207401764197,139.360778771,-0));
+#355=DIRECTION($,(0.707106781186548,0.707106781186548,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));
+#360=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,0));
#361=VERTEX_POINT($,#360);
-#362=CARTESIAN_POINT($,(298.96574017642,10,-0));
-#363=DIRECTION($,(0,1,0));
+#362=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,0));
+#363=DIRECTION($,(0.707106781186551,-0.707106781186544,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));
+#368=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,-0));
#369=VERTEX_POINT($,#368);
-#370=CARTESIAN_POINT($,(298.96574017642,40.77972,0));
-#371=DIRECTION($,(0,1,0));
+#370=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,0));
+#371=DIRECTION($,(-0.707106781186548,-0.707106781186547,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));
+#376=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,0));
#377=VERTEX_POINT($,#376);
-#378=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,0));
-#379=DIRECTION($,(0,1,0));
+#378=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,-0));
+#379=DIRECTION($,(1,0,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));
+#384=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,0));
#385=VERTEX_POINT($,#384);
-#386=CARTESIAN_POINT($,(298.96574017642,113.84300017642,0));
-#387=DIRECTION($,(0,1,0));
+#386=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,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));
+#392=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,0));
#393=VERTEX_POINT($,#392);
-#394=CARTESIAN_POINT($,(298.96574017642,125.313740352839,0));
-#395=DIRECTION($,(1,0,0));
+#394=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,0));
+#395=DIRECTION($,(0,-1,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));
+#400=CARTESIAN_POINT($,(74.1757401764197,53.47972,0));
#401=VERTEX_POINT($,#400);
-#402=CARTESIAN_POINT($,(305.873701758259,125.313740352839,-0));
-#403=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#402=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,0));
+#403=DIRECTION($,(0,-1,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));
+#408=CARTESIAN_POINT($,(74.1757401764197,10,-0));
#409=VERTEX_POINT($,#408);
-#410=CARTESIAN_POINT($,(300.710054488645,130.477387622454,0));
-#411=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#410=CARTESIAN_POINT($,(74.1757401764197,53.47972,0));
+#411=DIRECTION($,(0,-1,0));
#412=VECTOR($,#411,1);
#413=LINE($,#410,#412);
#414=EDGE_CURVE($,#401,#409,#413,.T.);
#415=ORIENTED_EDGE($,$,$,#414,.T.);
-#416=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));
+#416=CARTESIAN_POINT($,(131.32574017642,10,-0));
#417=VERTEX_POINT($,#416);
-#418=CARTESIAN_POINT($,(302.057092906805,131.824426040615,0));
-#419=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#418=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#419=DIRECTION($,(1,0,0));
#420=VECTOR($,#419,1);
#421=LINE($,#418,#420);
#422=EDGE_CURVE($,#409,#417,#421,.T.);
#423=ORIENTED_EDGE($,$,$,#422,.T.);
-#424=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
+#424=CARTESIAN_POINT($,(131.32574017642,35.4,0));
#425=VERTEX_POINT($,#424);
-#426=CARTESIAN_POINT($,(307.22074017642,126.660778771,-0));
+#426=CARTESIAN_POINT($,(131.32574017642,10,-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));
+#432=CARTESIAN_POINT($,(137.67574017642,41.75,0));
#433=VERTEX_POINT($,#432);
-#434=CARTESIAN_POINT($,(307.22074017642,133.568740352839,0));
-#435=DIRECTION($,(1,0,0));
+#434=CARTESIAN_POINT($,(131.32574017642,35.4,0));
+#435=DIRECTION($,(0.707106781186547,0.707106781186548,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));
+#440=CARTESIAN_POINT($,(251.97574017642,41.75,0));
#441=VERTEX_POINT($,#440);
-#442=CARTESIAN_POINT($,(318.691480352839,133.568740352839,0));
+#442=CARTESIAN_POINT($,(137.67574017642,41.75,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));
+#448=CARTESIAN_POINT($,(258.32574017642,35.4,0));
#449=VERTEX_POINT($,#448);
-#450=CARTESIAN_POINT($,(347.802420352839,133.568740352839,-0));
-#451=DIRECTION($,(0,1,0));
+#450=CARTESIAN_POINT($,(251.97574017642,41.75,0));
+#451=DIRECTION($,(0.707106781186547,-0.707106781186548,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));
+#456=CARTESIAN_POINT($,(258.32574017642,10,-0));
#457=VERTEX_POINT($,#456);
-#458=CARTESIAN_POINT($,(347.802420352839,248.351340352839,0));
-#459=DIRECTION($,(1,0,0));
+#458=CARTESIAN_POINT($,(258.32574017642,35.4,0));
+#459=DIRECTION($,(0,-1,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));
+#464=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#465=VERTEX_POINT($,#464);
+#466=CARTESIAN_POINT($,(258.32574017642,10,-0));
+#467=DIRECTION($,(1,0,0));
+#468=VECTOR($,#467,1);
+#469=LINE($,#466,#468);
+#470=EDGE_CURVE($,#457,#465,#469,.T.);
+#471=ORIENTED_EDGE($,$,$,#470,.T.);
+#472=CARTESIAN_POINT($,(298.96574017642,53.47972,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));
+#474=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#475=DIRECTION($,(0,1,0));
+#476=VECTOR($,#475,1);
+#477=LINE($,#474,#476);
+#478=EDGE_CURVE($,#465,#473,#477,.T.);
+#479=ORIENTED_EDGE($,$,$,#478,.T.);
+#480=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,0));
+#481=VERTEX_POINT($,#480);
+#482=CARTESIAN_POINT($,(298.96574017642,53.47972,0));
+#483=DIRECTION($,(0,1,0));
+#484=VECTOR($,#483,1);
+#485=LINE($,#482,#484);
+#486=EDGE_CURVE($,#473,#481,#485,.T.);
+#487=ORIENTED_EDGE($,$,$,#486,.T.);
+#488=CARTESIAN_POINT($,(298.96574017642,126.54300017642,0));
+#489=VERTEX_POINT($,#488);
+#490=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,0));
+#491=DIRECTION($,(0,1,0));
+#492=VECTOR($,#491,1);
+#493=LINE($,#490,#492);
+#494=EDGE_CURVE($,#481,#489,#493,.T.);
+#495=ORIENTED_EDGE($,$,$,#494,.T.);
+#496=CARTESIAN_POINT($,(298.96574017642,138.013740352839,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));
+#498=CARTESIAN_POINT($,(298.96574017642,126.54300017642,0));
+#499=DIRECTION($,(0,1,0));
+#500=VECTOR($,#499,1);
+#501=LINE($,#498,#500);
+#502=EDGE_CURVE($,#489,#497,#501,.T.);
+#503=ORIENTED_EDGE($,$,$,#502,.T.);
+#504=CARTESIAN_POINT($,(305.873701758259,138.013740352839,-0));
+#505=VERTEX_POINT($,#504);
+#506=CARTESIAN_POINT($,(298.96574017642,138.013740352839,0));
+#507=DIRECTION($,(1,0,0));
+#508=VECTOR($,#507,1);
+#509=LINE($,#506,#508);
+#510=EDGE_CURVE($,#497,#505,#509,.T.);
+#511=ORIENTED_EDGE($,$,$,#510,.T.);
+#512=CARTESIAN_POINT($,(300.710054488645,143.177387622454,0));
+#513=VERTEX_POINT($,#512);
+#514=CARTESIAN_POINT($,(305.873701758259,138.013740352839,-0));
+#515=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#516=VECTOR($,#515,1);
+#517=LINE($,#514,#516);
+#518=EDGE_CURVE($,#505,#513,#517,.T.);
+#519=ORIENTED_EDGE($,$,$,#518,.T.);
+#520=CARTESIAN_POINT($,(302.057092906805,144.524426040615,0));
+#521=VERTEX_POINT($,#520);
+#522=CARTESIAN_POINT($,(300.710054488645,143.177387622454,0));
+#523=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#524=VECTOR($,#523,1);
+#525=LINE($,#522,#524);
+#526=EDGE_CURVE($,#513,#521,#525,.T.);
+#527=ORIENTED_EDGE($,$,$,#526,.T.);
+#528=CARTESIAN_POINT($,(307.22074017642,139.360778771,-0));
+#529=VERTEX_POINT($,#528);
+#530=CARTESIAN_POINT($,(302.057092906805,144.524426040615,0));
+#531=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#532=VECTOR($,#531,1);
+#533=LINE($,#530,#532);
+#534=EDGE_CURVE($,#521,#529,#533,.T.);
+#535=ORIENTED_EDGE($,$,$,#534,.T.);
+#536=CARTESIAN_POINT($,(307.22074017642,146.268740352839,0));
+#537=VERTEX_POINT($,#536);
+#538=CARTESIAN_POINT($,(307.22074017642,139.360778771,-0));
+#539=DIRECTION($,(0,1,0));
+#540=VECTOR($,#539,1);
+#541=LINE($,#538,#540);
+#542=EDGE_CURVE($,#529,#537,#541,.T.);
+#543=ORIENTED_EDGE($,$,$,#542,.T.);
+#544=CARTESIAN_POINT($,(318.691480352839,146.268740352839,0));
+#545=VERTEX_POINT($,#544);
+#546=CARTESIAN_POINT($,(307.22074017642,146.268740352839,0));
+#547=DIRECTION($,(1,0,0));
+#548=VECTOR($,#547,1);
+#549=LINE($,#546,#548);
+#550=EDGE_CURVE($,#537,#545,#549,.T.);
+#551=ORIENTED_EDGE($,$,$,#550,.T.);
+#552=CARTESIAN_POINT($,(347.802420352839,146.268740352839,-0));
+#553=VERTEX_POINT($,#552);
+#554=CARTESIAN_POINT($,(318.691480352839,146.268740352839,0));
+#555=DIRECTION($,(1,0,0));
+#556=VECTOR($,#555,1);
+#557=LINE($,#554,#556);
+#558=EDGE_CURVE($,#545,#553,#557,.T.);
+#559=ORIENTED_EDGE($,$,$,#558,.T.);
+#560=CARTESIAN_POINT($,(347.802420352839,261.051340352839,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));
+#562=CARTESIAN_POINT($,(347.802420352839,146.268740352839,-0));
+#563=DIRECTION($,(0,1,0));
+#564=VECTOR($,#563,1);
+#565=LINE($,#562,#564);
+#566=EDGE_CURVE($,#553,#561,#565,.T.);
+#567=ORIENTED_EDGE($,$,$,#566,.T.);
+#568=CARTESIAN_POINT($,(353.537790441049,261.051340352839,0));
+#569=VERTEX_POINT($,#568);
+#570=CARTESIAN_POINT($,(347.802420352839,261.051340352839,0));
+#571=DIRECTION($,(1,0,0));
+#572=VECTOR($,#571,1);
+#573=LINE($,#570,#572);
+#574=EDGE_CURVE($,#561,#569,#573,.T.);
+#575=ORIENTED_EDGE($,$,$,#574,.T.);
+#576=CARTESIAN_POINT($,(353.537790441049,261.051340352839,0));
+#577=DIRECTION($,(1,0,0));
+#578=VECTOR($,#577,1);
+#579=LINE($,#576,#578);
+#580=EDGE_CURVE($,#569,#7,#579,.T.);
+#581=ORIENTED_EDGE($,$,$,#580,.T.);
+#582=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,#471,#479,#487,#495,#503,#511,#519,#527,#535,#543,#551,#559,#567,#575,#581));
+#583=FACE_OUTER_BOUND('',#582,.T.);
+#584=CARTESIAN_POINT($,(277.05824017642,176.700480352839,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));
+#586=CARTESIAN_POINT($,(261.18324017642,176.700480352839,0));
+#587=VERTEX_POINT($,#586);
+#588=CARTESIAN_POINT($,(269.12074017642,176.700480352839,0));
+#589=DIRECTION($,(0,0,1));
+#590=DIRECTION($,(1,0,0));
+#591=AXIS2_PLACEMENT_3D($,#588,#589,#590);
+#592=CIRCLE($,#591,7.9375);
+#593=TRIMMED_CURVE($,#592,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#594=EDGE_CURVE($,#585,#587,#593,.T.);
+#595=ORIENTED_EDGE($,$,$,#594,.F.);
+#596=CARTESIAN_POINT($,(269.12074017642,176.700480352839,0));
+#597=DIRECTION($,(0,0,1));
+#598=DIRECTION($,(1,0,0));
+#599=AXIS2_PLACEMENT_3D($,#596,#597,#598);
+#600=CIRCLE($,#599,7.9375);
+#601=TRIMMED_CURVE($,#600,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#602=EDGE_CURVE($,#587,#585,#601,.T.);
+#603=ORIENTED_EDGE($,$,$,#602,.F.);
+#604=EDGE_LOOP($,(#595,#603));
+#605=FACE_BOUND('',#604,.T.);
+#606=CARTESIAN_POINT($,(277.05824017642,221.150480352839,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));
+#608=CARTESIAN_POINT($,(261.18324017642,221.150480352839,0));
+#609=VERTEX_POINT($,#608);
+#610=CARTESIAN_POINT($,(269.12074017642,221.150480352839,0));
+#611=DIRECTION($,(0,0,1));
+#612=DIRECTION($,(1,0,0));
+#613=AXIS2_PLACEMENT_3D($,#610,#611,#612);
+#614=CIRCLE($,#613,7.9375);
+#615=TRIMMED_CURVE($,#614,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#616=EDGE_CURVE($,#607,#609,#615,.T.);
+#617=ORIENTED_EDGE($,$,$,#616,.F.);
+#618=CARTESIAN_POINT($,(269.12074017642,221.150480352839,0));
+#619=DIRECTION($,(0,0,1));
+#620=DIRECTION($,(1,0,0));
+#621=AXIS2_PLACEMENT_3D($,#618,#619,#620);
+#622=CIRCLE($,#621,7.9375);
+#623=TRIMMED_CURVE($,#622,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#624=EDGE_CURVE($,#609,#607,#623,.T.);
+#625=ORIENTED_EDGE($,$,$,#624,.F.);
+#626=EDGE_LOOP($,(#617,#625));
+#627=FACE_BOUND('',#626,.T.);
+#628=CARTESIAN_POINT($,(277.05824017642,265.600480352839,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));
+#630=CARTESIAN_POINT($,(261.18324017642,265.600480352839,0));
+#631=VERTEX_POINT($,#630);
+#632=CARTESIAN_POINT($,(269.12074017642,265.600480352839,0));
+#633=DIRECTION($,(0,0,1));
+#634=DIRECTION($,(1,0,0));
+#635=AXIS2_PLACEMENT_3D($,#632,#633,#634);
+#636=CIRCLE($,#635,7.9375);
+#637=TRIMMED_CURVE($,#636,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#638=EDGE_CURVE($,#629,#631,#637,.T.);
+#639=ORIENTED_EDGE($,$,$,#638,.F.);
+#640=CARTESIAN_POINT($,(269.12074017642,265.600480352839,0));
+#641=DIRECTION($,(0,0,1));
+#642=DIRECTION($,(1,0,0));
+#643=AXIS2_PLACEMENT_3D($,#640,#641,#642);
+#644=CIRCLE($,#643,7.9375);
+#645=TRIMMED_CURVE($,#644,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#646=EDGE_CURVE($,#631,#629,#645,.T.);
+#647=ORIENTED_EDGE($,$,$,#646,.F.);
+#648=EDGE_LOOP($,(#639,#647));
+#649=FACE_BOUND('',#648,.T.);
+#650=CARTESIAN_POINT($,(277.05824017642,310.050480352839,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));
+#652=CARTESIAN_POINT($,(261.18324017642,310.050480352839,0));
+#653=VERTEX_POINT($,#652);
+#654=CARTESIAN_POINT($,(269.12074017642,310.050480352839,0));
+#655=DIRECTION($,(0,0,1));
+#656=DIRECTION($,(1,0,0));
+#657=AXIS2_PLACEMENT_3D($,#654,#655,#656);
+#658=CIRCLE($,#657,7.9375);
+#659=TRIMMED_CURVE($,#658,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#660=EDGE_CURVE($,#651,#653,#659,.T.);
+#661=ORIENTED_EDGE($,$,$,#660,.F.);
+#662=CARTESIAN_POINT($,(269.12074017642,310.050480352839,0));
+#663=DIRECTION($,(0,0,1));
+#664=DIRECTION($,(1,0,0));
+#665=AXIS2_PLACEMENT_3D($,#662,#663,#664);
+#666=CIRCLE($,#665,7.9375);
+#667=TRIMMED_CURVE($,#666,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#668=EDGE_CURVE($,#653,#651,#667,.T.);
+#669=ORIENTED_EDGE($,$,$,#668,.F.);
+#670=EDGE_LOOP($,(#661,#669));
+#671=FACE_BOUND('',#670,.T.);
+#672=CARTESIAN_POINT($,(90.5333401764198,29.04746,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));
+#674=CARTESIAN_POINT($,(79.4081401764197,29.04746,0));
+#675=VERTEX_POINT($,#674);
+#676=CARTESIAN_POINT($,(84.9707401764198,29.04746,0));
+#677=DIRECTION($,(0,0,1));
+#678=DIRECTION($,(1,0,0));
+#679=AXIS2_PLACEMENT_3D($,#676,#677,#678);
+#680=CIRCLE($,#679,5.5626);
+#681=TRIMMED_CURVE($,#680,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#682=EDGE_CURVE($,#673,#675,#681,.T.);
+#683=ORIENTED_EDGE($,$,$,#682,.F.);
+#684=CARTESIAN_POINT($,(84.9707401764198,29.04746,0));
+#685=DIRECTION($,(0,0,1));
+#686=DIRECTION($,(1,0,0));
+#687=AXIS2_PLACEMENT_3D($,#684,#685,#686);
+#688=CIRCLE($,#687,5.5626);
+#689=TRIMMED_CURVE($,#688,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#690=EDGE_CURVE($,#675,#673,#689,.T.);
+#691=ORIENTED_EDGE($,$,$,#690,.F.);
+#692=EDGE_LOOP($,(#683,#691));
+#693=FACE_BOUND('',#692,.T.);
+#694=CARTESIAN_POINT($,(293.73334017642,29.04746,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));
+#696=CARTESIAN_POINT($,(282.60814017642,29.04746,0));
+#697=VERTEX_POINT($,#696);
+#698=CARTESIAN_POINT($,(288.17074017642,29.04746,0));
+#699=DIRECTION($,(0,0,1));
+#700=DIRECTION($,(1,0,0));
+#701=AXIS2_PLACEMENT_3D($,#698,#699,#700);
+#702=CIRCLE($,#701,5.5626);
+#703=TRIMMED_CURVE($,#702,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#704=EDGE_CURVE($,#695,#697,#703,.T.);
+#705=ORIENTED_EDGE($,$,$,#704,.F.);
+#706=CARTESIAN_POINT($,(288.17074017642,29.04746,0));
+#707=DIRECTION($,(0,0,1));
+#708=DIRECTION($,(1,0,0));
+#709=AXIS2_PLACEMENT_3D($,#706,#707,#708);
+#710=CIRCLE($,#709,5.5626);
+#711=TRIMMED_CURVE($,#710,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#712=EDGE_CURVE($,#697,#695,#711,.T.);
+#713=ORIENTED_EDGE($,$,$,#712,.F.);
+#714=EDGE_LOOP($,(#705,#713));
+#715=FACE_BOUND('',#714,.T.);
+#716=CARTESIAN_POINT($,(263.25334017642,411.447280352839,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));
+#718=CARTESIAN_POINT($,(225.15334017642,411.447280352839,0));
+#719=VERTEX_POINT($,#718);
+#720=CARTESIAN_POINT($,(244.20334017642,411.447280352839,0));
+#721=DIRECTION($,(0,0,1));
+#722=DIRECTION($,(1,0,0));
+#723=AXIS2_PLACEMENT_3D($,#720,#721,#722);
+#724=CIRCLE($,#723,19.05);
+#725=TRIMMED_CURVE($,#724,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#726=EDGE_CURVE($,#717,#719,#725,.T.);
+#727=ORIENTED_EDGE($,$,$,#726,.F.);
+#728=CARTESIAN_POINT($,(244.20334017642,411.447280352839,0));
+#729=DIRECTION($,(0,0,1));
+#730=DIRECTION($,(1,0,0));
+#731=AXIS2_PLACEMENT_3D($,#728,#729,#730);
+#732=CIRCLE($,#731,19.05);
+#733=TRIMMED_CURVE($,#732,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#734=EDGE_CURVE($,#719,#717,#733,.T.);
+#735=ORIENTED_EDGE($,$,$,#734,.F.);
+#736=EDGE_LOOP($,(#727,#735));
+#737=FACE_BOUND('',#736,.T.);
+#738=CARTESIAN_POINT($,(180.70334017642,436.847280352839,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));
+#740=CARTESIAN_POINT($,(129.90334017642,436.847280352839,0));
+#741=VERTEX_POINT($,#740);
+#742=CARTESIAN_POINT($,(155.30334017642,436.847280352839,0));
+#743=DIRECTION($,(0,0,1));
+#744=DIRECTION($,(1,0,0));
+#745=AXIS2_PLACEMENT_3D($,#742,#743,#744);
+#746=CIRCLE($,#745,25.4);
+#747=TRIMMED_CURVE($,#746,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#748=EDGE_CURVE($,#739,#741,#747,.T.);
+#749=ORIENTED_EDGE($,$,$,#748,.F.);
+#750=CARTESIAN_POINT($,(155.30334017642,436.847280352839,0));
+#751=DIRECTION($,(0,0,1));
+#752=DIRECTION($,(1,0,0));
+#753=AXIS2_PLACEMENT_3D($,#750,#751,#752);
+#754=CIRCLE($,#753,25.4);
+#755=TRIMMED_CURVE($,#754,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#756=EDGE_CURVE($,#741,#739,#755,.T.);
+#757=ORIENTED_EDGE($,$,$,#756,.F.);
+#758=EDGE_LOOP($,(#749,#757));
+#759=FACE_BOUND('',#758,.T.);
+#760=CARTESIAN_POINT($,(293.73334017642,616.250300705679,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));
+#762=CARTESIAN_POINT($,(282.60814017642,616.250300705679,0));
+#763=VERTEX_POINT($,#762);
+#764=CARTESIAN_POINT($,(288.17074017642,616.250300705679,0));
+#765=DIRECTION($,(0,0,1));
+#766=DIRECTION($,(1,0,0));
+#767=AXIS2_PLACEMENT_3D($,#764,#765,#766);
+#768=CIRCLE($,#767,5.5626);
+#769=TRIMMED_CURVE($,#768,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#770=EDGE_CURVE($,#761,#763,#769,.T.);
+#771=ORIENTED_EDGE($,$,$,#770,.F.);
+#772=CARTESIAN_POINT($,(288.17074017642,616.250300705679,0));
+#773=DIRECTION($,(0,0,1));
+#774=DIRECTION($,(1,0,0));
+#775=AXIS2_PLACEMENT_3D($,#772,#773,#774);
+#776=CIRCLE($,#775,5.5626);
+#777=TRIMMED_CURVE($,#776,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#778=EDGE_CURVE($,#763,#761,#777,.T.);
+#779=ORIENTED_EDGE($,$,$,#778,.F.);
+#780=EDGE_LOOP($,(#771,#779));
+#781=FACE_BOUND('',#780,.T.);
+#782=CARTESIAN_POINT($,(90.5333401764198,616.250300705679,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));
+#784=CARTESIAN_POINT($,(79.4081401764197,616.250300705679,0));
+#785=VERTEX_POINT($,#784);
+#786=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,0));
+#787=DIRECTION($,(0,0,1));
+#788=DIRECTION($,(1,0,0));
+#789=AXIS2_PLACEMENT_3D($,#786,#787,#788);
+#790=CIRCLE($,#789,5.5626);
+#791=TRIMMED_CURVE($,#790,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#792=EDGE_CURVE($,#783,#785,#791,.T.);
+#793=ORIENTED_EDGE($,$,$,#792,.F.);
+#794=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,0));
+#795=DIRECTION($,(0,0,1));
+#796=DIRECTION($,(1,0,0));
+#797=AXIS2_PLACEMENT_3D($,#794,#795,#796);
+#798=CIRCLE($,#797,5.5626);
+#799=TRIMMED_CURVE($,#798,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#800=EDGE_CURVE($,#785,#783,#799,.T.);
+#801=ORIENTED_EDGE($,$,$,#800,.F.);
+#802=EDGE_LOOP($,(#793,#801));
+#803=FACE_BOUND('',#802,.T.);
+#804=CARTESIAN_POINT($,(397.799086493049,324.551340352839,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.);
+#806=CARTESIAN_POINT($,(370.748086493049,324.551340352839,0));
+#807=VERTEX_POINT($,#806);
+#808=CARTESIAN_POINT($,(384.273586493049,324.551340352839,0));
+#809=DIRECTION($,(0,0,1));
+#810=DIRECTION($,(1,0,0));
+#811=AXIS2_PLACEMENT_3D($,#808,#809,#810);
+#812=CIRCLE($,#811,13.5255);
+#813=TRIMMED_CURVE($,#812,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#814=EDGE_CURVE($,#805,#807,#813,.T.);
+#815=ORIENTED_EDGE($,$,$,#814,.F.);
+#816=CARTESIAN_POINT($,(384.273586493049,324.551340352839,0));
+#817=DIRECTION($,(0,0,1));
+#818=DIRECTION($,(1,0,0));
+#819=AXIS2_PLACEMENT_3D($,#816,#817,#818);
+#820=CIRCLE($,#819,13.5255);
+#821=TRIMMED_CURVE($,#820,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#822=EDGE_CURVE($,#807,#805,#821,.T.);
+#823=ORIENTED_EDGE($,$,$,#822,.F.);
+#824=EDGE_LOOP($,(#815,#823));
+#825=FACE_BOUND('',#824,.T.);
+#826=CARTESIAN_POINT($,(372.684836493049,305.501340352839,0));
+#827=VERTEX_POINT($,#826);
+#828=CARTESIAN_POINT($,(367.922336493049,305.501340352839,0));
+#829=VERTEX_POINT($,#828);
+#830=CARTESIAN_POINT($,(370.303586493049,305.501340352839,0));
+#831=DIRECTION($,(0,0,1));
+#832=DIRECTION($,(1,0,0));
+#833=AXIS2_PLACEMENT_3D($,#830,#831,#832);
+#834=CIRCLE($,#833,2.38125);
+#835=TRIMMED_CURVE($,#834,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#836=EDGE_CURVE($,#827,#829,#835,.T.);
+#837=ORIENTED_EDGE($,$,$,#836,.F.);
+#838=CARTESIAN_POINT($,(370.303586493049,305.501340352839,0));
+#839=DIRECTION($,(0,0,1));
+#840=DIRECTION($,(1,0,0));
+#841=AXIS2_PLACEMENT_3D($,#838,#839,#840);
+#842=CIRCLE($,#841,2.38125);
+#843=TRIMMED_CURVE($,#842,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#844=EDGE_CURVE($,#829,#827,#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.);
+#846=EDGE_LOOP($,(#837,#845));
+#847=FACE_BOUND('',#846,.T.);
+#848=CARTESIAN_POINT($,(372.684836493049,343.601340352839,0));
+#849=VERTEX_POINT($,#848);
+#850=CARTESIAN_POINT($,(367.922336493049,343.601340352839,0));
+#851=VERTEX_POINT($,#850);
+#852=CARTESIAN_POINT($,(370.303586493049,343.601340352839,0));
+#853=DIRECTION($,(0,0,1));
+#854=DIRECTION($,(1,0,0));
+#855=AXIS2_PLACEMENT_3D($,#852,#853,#854);
+#856=CIRCLE($,#855,2.38125);
+#857=TRIMMED_CURVE($,#856,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#858=EDGE_CURVE($,#849,#851,#857,.T.);
+#859=ORIENTED_EDGE($,$,$,#858,.F.);
+#860=CARTESIAN_POINT($,(370.303586493049,343.601340352839,0));
+#861=DIRECTION($,(0,0,1));
+#862=DIRECTION($,(1,0,0));
+#863=AXIS2_PLACEMENT_3D($,#860,#861,#862);
+#864=CIRCLE($,#863,2.38125);
+#865=TRIMMED_CURVE($,#864,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#866=EDGE_CURVE($,#851,#849,#865,.T.);
#867=ORIENTED_EDGE($,$,$,#866,.F.);
-#868=EDGE_LOOP($,(#845,#853,#861,#867));
+#868=EDGE_LOOP($,(#859,#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));
+#870=CARTESIAN_POINT($,(404.434836493049,305.501340352839,0));
+#871=VERTEX_POINT($,#870);
+#872=CARTESIAN_POINT($,(399.672336493049,305.501340352839,0));
+#873=VERTEX_POINT($,#872);
+#874=CARTESIAN_POINT($,(402.053586493049,305.501340352839,0));
+#875=DIRECTION($,(0,0,1));
+#876=DIRECTION($,(1,0,0));
+#877=AXIS2_PLACEMENT_3D($,#874,#875,#876);
+#878=CIRCLE($,#877,2.38125);
+#879=TRIMMED_CURVE($,#878,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#880=EDGE_CURVE($,#871,#873,#879,.T.);
+#881=ORIENTED_EDGE($,$,$,#880,.F.);
+#882=CARTESIAN_POINT($,(402.053586493049,305.501340352839,0));
+#883=DIRECTION($,(0,0,1));
+#884=DIRECTION($,(1,0,0));
+#885=AXIS2_PLACEMENT_3D($,#882,#883,#884);
+#886=CIRCLE($,#885,2.38125);
+#887=TRIMMED_CURVE($,#886,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#888=EDGE_CURVE($,#873,#871,#887,.T.);
+#889=ORIENTED_EDGE($,$,$,#888,.F.);
+#890=EDGE_LOOP($,(#881,#889));
+#891=FACE_BOUND('',#890,.T.);
+#892=CARTESIAN_POINT($,(404.434836493049,343.601340352839,0));
+#893=VERTEX_POINT($,#892);
+#894=CARTESIAN_POINT($,(399.672336493049,343.601340352839,0));
#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));
+#896=CARTESIAN_POINT($,(402.053586493049,343.601340352839,0));
+#897=DIRECTION($,(0,0,1));
+#898=DIRECTION($,(1,0,0));
+#899=AXIS2_PLACEMENT_3D($,#896,#897,#898);
+#900=CIRCLE($,#899,2.38125);
+#901=TRIMMED_CURVE($,#900,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#902=EDGE_CURVE($,#893,#895,#901,.T.);
+#903=ORIENTED_EDGE($,$,$,#902,.F.);
+#904=CARTESIAN_POINT($,(402.053586493049,343.601340352839,0));
+#905=DIRECTION($,(0,0,1));
+#906=DIRECTION($,(1,0,0));
+#907=AXIS2_PLACEMENT_3D($,#904,#905,#906);
+#908=CIRCLE($,#907,2.38125);
+#909=TRIMMED_CURVE($,#908,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#910=EDGE_CURVE($,#895,#893,#909,.T.);
+#911=ORIENTED_EDGE($,$,$,#910,.F.);
+#912=EDGE_LOOP($,(#903,#911));
+#913=FACE_BOUND('',#912,.T.);
+#914=CARTESIAN_POINT($,(107.67834017642,201.998880352839,-0));
+#915=VERTEX_POINT($,#914);
+#916=CARTESIAN_POINT($,(126.72834017642,201.998880352839,0));
+#917=VERTEX_POINT($,#916);
+#918=CARTESIAN_POINT($,(107.67834017642,201.998880352839,-0));
+#919=DIRECTION($,(1,0,0));
+#920=VECTOR($,#919,1);
+#921=LINE($,#918,#920);
+#922=EDGE_CURVE($,#915,#917,#921,.T.);
+#923=ORIENTED_EDGE($,$,$,#922,.F.);
+#924=CARTESIAN_POINT($,(107.67834017642,290.898880352839,-0));
+#925=VERTEX_POINT($,#924);
+#926=CARTESIAN_POINT($,(107.67834017642,290.898880352839,-0));
+#927=DIRECTION($,(0,-1,0));
+#928=VECTOR($,#927,1);
+#929=LINE($,#926,#928);
+#930=EDGE_CURVE($,#925,#915,#929,.T.);
+#931=ORIENTED_EDGE($,$,$,#930,.F.);
+#932=CARTESIAN_POINT($,(126.72834017642,290.898880352839,-0));
+#933=VERTEX_POINT($,#932);
+#934=CARTESIAN_POINT($,(126.72834017642,290.898880352839,-0));
+#935=DIRECTION($,(-1,0,0));
+#936=VECTOR($,#935,1);
+#937=LINE($,#934,#936);
+#938=EDGE_CURVE($,#933,#925,#937,.T.);
+#939=ORIENTED_EDGE($,$,$,#938,.F.);
+#940=CARTESIAN_POINT($,(126.72834017642,201.998880352839,0));
+#941=DIRECTION($,(0,1,0));
+#942=VECTOR($,#941,1);
+#943=LINE($,#940,#942);
+#944=EDGE_CURVE($,#917,#933,#943,.T.);
+#945=ORIENTED_EDGE($,$,$,#944,.F.);
+#946=EDGE_LOOP($,(#923,#931,#939,#945));
+#947=FACE_BOUND('',#946,.T.);
+#948=CARTESIAN_POINT($,(171.17834017642,201.998880352839,-0));
+#949=VERTEX_POINT($,#948);
+#950=CARTESIAN_POINT($,(190.22834017642,201.998880352839,0));
#951=VERTEX_POINT($,#950);
-#952=CARTESIAN_POINT($,(318.691480352839,485.358740352839,1.905));
-#953=DIRECTION($,(-1,0,0));
+#952=CARTESIAN_POINT($,(171.17834017642,201.998880352839,-0));
+#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));
+#956=EDGE_CURVE($,#949,#951,#955,.T.);
+#957=ORIENTED_EDGE($,$,$,#956,.F.);
+#958=CARTESIAN_POINT($,(171.17834017642,290.898880352839,-0));
#959=VERTEX_POINT($,#958);
-#960=CARTESIAN_POINT($,(307.22074017642,485.35874035284,1.905));
-#961=DIRECTION($,(0,1,0));
+#960=CARTESIAN_POINT($,(171.17834017642,290.898880352839,-0));
+#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));
+#964=EDGE_CURVE($,#959,#949,#963,.T.);
+#965=ORIENTED_EDGE($,$,$,#964,.F.);
+#966=CARTESIAN_POINT($,(190.22834017642,290.898880352839,-0));
#967=VERTEX_POINT($,#966);
-#968=CARTESIAN_POINT($,(307.22074017642,492.266701934679,1.905));
-#969=DIRECTION($,(-0.707106781186548,-0.707106781186548,0));
+#968=CARTESIAN_POINT($,(190.22834017642,290.898880352839,-0));
+#969=DIRECTION($,(-1,0,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));
+#972=EDGE_CURVE($,#967,#959,#971,.T.);
+#973=ORIENTED_EDGE($,$,$,#972,.F.);
+#974=CARTESIAN_POINT($,(190.22834017642,201.998880352839,0));
+#975=DIRECTION($,(0,1,0));
+#976=VECTOR($,#975,1);
+#977=LINE($,#974,#976);
+#978=EDGE_CURVE($,#951,#967,#977,.T.);
+#979=ORIENTED_EDGE($,$,$,#978,.F.);
+#980=EDGE_LOOP($,(#957,#965,#973,#979));
+#981=FACE_BOUND('',#980,.T.);
+#982=ADVANCED_FACE('',(#583,#605,#627,#649,#671,#693,#715,#737,#759,#781,#803,#825,#847,#869,#891,#913,#947,#981),#5,.T.);
+#983=CARTESIAN_POINT($,(0,0,1.905));
+#984=DIRECTION($,(0,0,1));
+#985=DIRECTION($,(1,0,0));
+#986=AXIS2_PLACEMENT_3D($,#983,#984,#985);
+#987=PLANE($,#986);
+#988=CARTESIAN_POINT($,(402.051790441049,261.051340352839,1.905));
+#989=VERTEX_POINT($,#988);
+#990=CARTESIAN_POINT($,(402.051790441049,273.751340352839,1.905));
#991=VERTEX_POINT($,#990);
-#992=CARTESIAN_POINT($,(305.873701758259,493.613740352839,1.905));
-#993=DIRECTION($,(-1,0,0));
+#992=CARTESIAN_POINT($,(402.051790441049,261.051340352839,1.905));
+#993=DIRECTION($,(0,1,0));
#994=VECTOR($,#993,1);
#995=LINE($,#992,#994);
-#996=EDGE_CURVE($,#983,#991,#995,.T.);
+#996=EDGE_CURVE($,#989,#991,#995,.T.);
#997=ORIENTED_EDGE($,$,$,#996,.T.);
-#998=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#998=CARTESIAN_POINT($,(414.751790441049,273.751340352839,1.905));
#999=VERTEX_POINT($,#998);
-#1000=CARTESIAN_POINT($,(298.96574017642,493.613740352839,1.905));
-#1001=DIRECTION($,(0,1,0));
+#1000=CARTESIAN_POINT($,(402.051790441049,273.751340352839,1.905));
+#1001=DIRECTION($,(1,0,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));
+#1006=CARTESIAN_POINT($,(414.751790441049,375.351340352839,1.905));
#1007=VERTEX_POINT($,#1006);
-#1008=CARTESIAN_POINT($,(298.96574017642,505.084480529259,1.905));
+#1008=CARTESIAN_POINT($,(414.751790441049,273.751340352839,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));
+#1014=CARTESIAN_POINT($,(402.051790441049,375.351340352839,1.905));
#1015=VERTEX_POINT($,#1014);
-#1016=CARTESIAN_POINT($,(298.96574017642,566.677020529259,1.905));
-#1017=DIRECTION($,(0,1,0));
+#1016=CARTESIAN_POINT($,(414.751790441049,375.351340352839,1.905));
+#1017=DIRECTION($,(-1,0,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));
+#1022=CARTESIAN_POINT($,(402.051790441049,388.051340352839,1.905));
#1023=VERTEX_POINT($,#1022);
-#1024=CARTESIAN_POINT($,(298.96574017642,578.147760705679,1.905));
+#1024=CARTESIAN_POINT($,(402.051790441049,375.351340352839,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));
+#1030=CARTESIAN_POINT($,(353.537790441049,388.051340352839,1.905));
#1031=VERTEX_POINT($,#1030);
-#1032=CARTESIAN_POINT($,(298.96574017642,622.597760705679,1.905));
+#1032=CARTESIAN_POINT($,(402.051790441049,388.051340352839,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));
+#1038=CARTESIAN_POINT($,(347.802420352839,388.051340352839,1.905));
#1039=VERTEX_POINT($,#1038);
-#1040=CARTESIAN_POINT($,(74.1757401764197,622.597760705679,1.905));
-#1041=DIRECTION($,(0,-1,0));
+#1040=CARTESIAN_POINT($,(353.537790441049,388.051340352839,1.905));
+#1041=DIRECTION($,(-1,0,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));
+#1046=CARTESIAN_POINT($,(347.802420352839,498.058740352839,1.905));
#1047=VERTEX_POINT($,#1046);
-#1048=CARTESIAN_POINT($,(74.1757401764197,578.147760705679,1.905));
-#1049=DIRECTION($,(0,-1,0));
+#1048=CARTESIAN_POINT($,(347.802420352839,388.051340352839,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));
+#1054=CARTESIAN_POINT($,(318.691480352839,498.058740352839,1.905));
#1055=VERTEX_POINT($,#1054);
-#1056=CARTESIAN_POINT($,(74.1757401764197,566.677020529259,1.905));
-#1057=DIRECTION($,(0,-1,0));
+#1056=CARTESIAN_POINT($,(347.802420352839,498.058740352839,1.905));
+#1057=DIRECTION($,(-1,0,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));
+#1062=CARTESIAN_POINT($,(307.22074017642,498.058740352839,1.905));
#1063=VERTEX_POINT($,#1062);
-#1064=CARTESIAN_POINT($,(74.1757401764197,505.084480529259,1.905));
-#1065=DIRECTION($,(0,-1,0));
+#1064=CARTESIAN_POINT($,(318.691480352839,498.058740352839,1.905));
+#1065=DIRECTION($,(-1,0,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));
+#1070=CARTESIAN_POINT($,(307.22074017642,504.966701934679,1.905));
#1071=VERTEX_POINT($,#1070);
-#1072=CARTESIAN_POINT($,(74.1757401764197,493.613740352839,1.905));
-#1073=DIRECTION($,(-1,0,0));
+#1072=CARTESIAN_POINT($,(307.22074017642,498.058740352839,1.905));
+#1073=DIRECTION($,(0,1,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));
+#1078=CARTESIAN_POINT($,(302.057092906805,499.803054665064,1.905));
#1079=VERTEX_POINT($,#1078);
-#1080=CARTESIAN_POINT($,(67.2677785945802,493.613740352839,1.905));
-#1081=DIRECTION($,(0.707106781186545,-0.70710678118655,0));
+#1080=CARTESIAN_POINT($,(307.22074017642,504.966701934679,1.905));
+#1081=DIRECTION($,(-0.707106781186548,-0.707106781186548,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));
+#1086=CARTESIAN_POINT($,(300.710054488645,501.150093083225,1.905));
#1087=VERTEX_POINT($,#1086);
-#1088=CARTESIAN_POINT($,(72.4314258641949,488.450093083225,1.905));
-#1089=DIRECTION($,(-0.707106781186536,-0.707106781186559,0));
+#1088=CARTESIAN_POINT($,(302.057092906805,499.803054665064,1.905));
+#1089=DIRECTION($,(-0.707106781186533,0.707106781186562,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));
+#1094=CARTESIAN_POINT($,(305.873701758259,506.313740352839,1.905));
#1095=VERTEX_POINT($,#1094);
-#1096=CARTESIAN_POINT($,(71.0843874460345,487.103054665064,1.905));
-#1097=DIRECTION($,(-0.707106781186545,0.70710678118655,0));
+#1096=CARTESIAN_POINT($,(300.710054488645,501.150093083225,1.905));
+#1097=DIRECTION($,(0.707106781186548,0.707106781186548,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));
+#1102=CARTESIAN_POINT($,(298.96574017642,506.313740352839,1.905));
#1103=VERTEX_POINT($,#1102);
-#1104=CARTESIAN_POINT($,(65.9207401764197,492.266701934679,1.905));
-#1105=DIRECTION($,(0,-1,0));
+#1104=CARTESIAN_POINT($,(305.873701758259,506.313740352839,1.905));
+#1105=DIRECTION($,(-1,0,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));
+#1110=CARTESIAN_POINT($,(298.96574017642,517.784480529259,1.905));
#1111=VERTEX_POINT($,#1110);
-#1112=CARTESIAN_POINT($,(65.9207401764197,485.35874035284,1.905));
-#1113=DIRECTION($,(-1,0,0));
+#1112=CARTESIAN_POINT($,(298.96574017642,506.313740352839,1.905));
+#1113=DIRECTION($,(0,1,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));
+#1118=CARTESIAN_POINT($,(298.96574017642,579.377020529259,1.905));
#1119=VERTEX_POINT($,#1118);
-#1120=CARTESIAN_POINT($,(54.45,485.35874035284,1.905));
-#1121=DIRECTION($,(-1,0,0));
+#1120=CARTESIAN_POINT($,(298.96574017642,517.784480529259,1.905));
+#1121=DIRECTION($,(0,1,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));
+#1126=CARTESIAN_POINT($,(298.96574017642,590.847760705679,1.905));
#1127=VERTEX_POINT($,#1126);
-#1128=CARTESIAN_POINT($,(10,485.35874035284,1.905));
-#1129=DIRECTION($,(0,-1,0));
+#1128=CARTESIAN_POINT($,(298.96574017642,579.377020529259,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));
+#1134=CARTESIAN_POINT($,(298.96574017642,635.297760705679,1.905));
#1135=VERTEX_POINT($,#1134);
-#1136=CARTESIAN_POINT($,(10,133.568740352839,1.905));
-#1137=DIRECTION($,(1,0,0));
+#1136=CARTESIAN_POINT($,(298.96574017642,590.847760705679,1.905));
+#1137=DIRECTION($,(0,1,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));
+#1142=CARTESIAN_POINT($,(248.16574017642,635.297760705679,1.905));
#1143=VERTEX_POINT($,#1142);
-#1144=CARTESIAN_POINT($,(54.45,133.568740352839,1.905));
-#1145=DIRECTION($,(1,0,0));
+#1144=CARTESIAN_POINT($,(298.96574017642,635.297760705679,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));
+#1150=CARTESIAN_POINT($,(241.81574017642,628.947760705679,1.905));
#1151=VERTEX_POINT($,#1150);
-#1152=CARTESIAN_POINT($,(65.9207401764197,133.568740352839,1.905));
-#1153=DIRECTION($,(0,-1,0));
+#1152=CARTESIAN_POINT($,(248.16574017642,635.297760705679,1.905));
+#1153=DIRECTION($,(-0.707106781186546,-0.707106781186549,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));
+#1158=CARTESIAN_POINT($,(241.81574017642,609.897760705679,1.905));
#1159=VERTEX_POINT($,#1158);
-#1160=CARTESIAN_POINT($,(65.9207401764197,126.660778771,1.905));
-#1161=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1160=CARTESIAN_POINT($,(241.81574017642,628.947760705679,1.905));
+#1161=DIRECTION($,(0,-1,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));
+#1166=CARTESIAN_POINT($,(235.46574017642,603.547760705679,1.905));
#1167=VERTEX_POINT($,#1166);
-#1168=CARTESIAN_POINT($,(71.0843874460345,131.824426040615,1.905));
-#1169=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#1168=CARTESIAN_POINT($,(241.81574017642,609.897760705679,1.905));
+#1169=DIRECTION($,(-0.707106781186546,-0.707106781186549,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));
+#1174=CARTESIAN_POINT($,(121.16574017642,603.547760705679,1.905));
#1175=VERTEX_POINT($,#1174);
-#1176=CARTESIAN_POINT($,(72.4314258641949,130.477387622454,1.905));
-#1177=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#1176=CARTESIAN_POINT($,(235.46574017642,603.547760705679,1.905));
+#1177=DIRECTION($,(-1,0,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));
+#1182=CARTESIAN_POINT($,(114.81574017642,609.897760705679,1.905));
#1183=VERTEX_POINT($,#1182);
-#1184=CARTESIAN_POINT($,(67.2677785945801,125.313740352839,1.905));
-#1185=DIRECTION($,(1,0,0));
+#1184=CARTESIAN_POINT($,(121.16574017642,603.547760705679,1.905));
+#1185=DIRECTION($,(-0.707106781186546,0.707106781186549,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));
+#1190=CARTESIAN_POINT($,(114.81574017642,628.947760705679,1.905));
#1191=VERTEX_POINT($,#1190);
-#1192=CARTESIAN_POINT($,(74.1757401764197,125.313740352839,1.905));
-#1193=DIRECTION($,(0,-1,0));
+#1192=CARTESIAN_POINT($,(114.81574017642,609.897760705679,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));
+#1198=CARTESIAN_POINT($,(108.46574017642,635.297760705679,1.905));
#1199=VERTEX_POINT($,#1198);
-#1200=CARTESIAN_POINT($,(74.1757401764197,113.84300017642,1.905));
-#1201=DIRECTION($,(0,-1,0));
+#1200=CARTESIAN_POINT($,(114.81574017642,628.947760705679,1.905));
+#1201=DIRECTION($,(-0.707106781186546,0.707106781186549,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));
+#1206=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,1.905));
#1207=VERTEX_POINT($,#1206);
-#1208=CARTESIAN_POINT($,(74.1757401764197,52.2504601764197,1.905));
-#1209=DIRECTION($,(0,-1,0));
+#1208=CARTESIAN_POINT($,(108.46574017642,635.297760705679,1.905));
+#1209=DIRECTION($,(-1,0,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));
+#1214=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,1.905));
#1215=VERTEX_POINT($,#1214);
-#1216=CARTESIAN_POINT($,(74.1757401764197,40.77972,1.905));
+#1216=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,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));
+#1222=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,1.905));
#1223=VERTEX_POINT($,#1222);
-#1224=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
-#1225=DIRECTION($,(1,0,0));
+#1224=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,1.905));
+#1225=DIRECTION($,(0,-1,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));
+#1230=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,1.905));
#1231=VERTEX_POINT($,#1230);
-#1232=CARTESIAN_POINT($,(298.96574017642,10,1.905));
-#1233=DIRECTION($,(0,1,0));
+#1232=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,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));
+#1238=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,1.905));
#1239=VERTEX_POINT($,#1238);
-#1240=CARTESIAN_POINT($,(298.96574017642,40.77972,1.905));
-#1241=DIRECTION($,(0,1,0));
+#1240=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,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));
+#1246=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,1.905));
#1247=VERTEX_POINT($,#1246);
-#1248=CARTESIAN_POINT($,(298.96574017642,52.2504601764197,1.905));
-#1249=DIRECTION($,(0,1,0));
+#1248=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,1.905));
+#1249=DIRECTION($,(-1,0,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));
+#1254=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,1.905));
#1255=VERTEX_POINT($,#1254);
-#1256=CARTESIAN_POINT($,(298.96574017642,113.84300017642,1.905));
-#1257=DIRECTION($,(0,1,0));
+#1256=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,1.905));
+#1257=DIRECTION($,(0.707106781186549,-0.707106781186547,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));
+#1262=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,1.905));
#1263=VERTEX_POINT($,#1262);
-#1264=CARTESIAN_POINT($,(298.96574017642,125.313740352839,1.905));
-#1265=DIRECTION($,(1,0,0));
+#1264=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,1.905));
+#1265=DIRECTION($,(-0.707106781186536,-0.707106781186559,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));
+#1270=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,1.905));
#1271=VERTEX_POINT($,#1270);
-#1272=CARTESIAN_POINT($,(305.873701758259,125.313740352839,1.905));
-#1273=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#1272=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,1.905));
+#1273=DIRECTION($,(-0.707106781186549,0.707106781186547,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));
+#1278=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,1.905));
#1279=VERTEX_POINT($,#1278);
-#1280=CARTESIAN_POINT($,(300.710054488645,130.477387622454,1.905));
-#1281=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1280=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,1.905));
+#1281=DIRECTION($,(0,-1,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));
+#1286=CARTESIAN_POINT($,(54.45,498.058740352839,1.905));
#1287=VERTEX_POINT($,#1286);
-#1288=CARTESIAN_POINT($,(302.057092906805,131.824426040615,1.905));
-#1289=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#1288=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,1.905));
+#1289=DIRECTION($,(-1,0,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));
+#1294=CARTESIAN_POINT($,(10,498.058740352839,1.905));
#1295=VERTEX_POINT($,#1294);
-#1296=CARTESIAN_POINT($,(307.22074017642,126.660778771,1.905));
-#1297=DIRECTION($,(0,1,0));
+#1296=CARTESIAN_POINT($,(54.45,498.058740352839,1.905));
+#1297=DIRECTION($,(-1,0,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));
+#1302=CARTESIAN_POINT($,(10,146.268740352839,1.905));
#1303=VERTEX_POINT($,#1302);
-#1304=CARTESIAN_POINT($,(307.22074017642,133.568740352839,1.905));
-#1305=DIRECTION($,(1,0,0));
+#1304=CARTESIAN_POINT($,(10,498.058740352839,1.905));
+#1305=DIRECTION($,(0,-1,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));
+#1310=CARTESIAN_POINT($,(54.45,146.268740352839,1.905));
#1311=VERTEX_POINT($,#1310);
-#1312=CARTESIAN_POINT($,(318.691480352839,133.568740352839,1.905));
+#1312=CARTESIAN_POINT($,(10,146.268740352839,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));
+#1318=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,1.905));
#1319=VERTEX_POINT($,#1318);
-#1320=CARTESIAN_POINT($,(347.802420352839,133.568740352839,1.905));
-#1321=DIRECTION($,(0,1,0));
+#1320=CARTESIAN_POINT($,(54.45,146.268740352839,1.905));
+#1321=DIRECTION($,(1,0,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));
+#1326=CARTESIAN_POINT($,(65.9207401764197,139.360778771,1.905));
#1327=VERTEX_POINT($,#1326);
-#1328=CARTESIAN_POINT($,(347.802420352839,248.351340352839,1.905));
-#1329=DIRECTION($,(1,0,0));
+#1328=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,1.905));
+#1329=DIRECTION($,(0,-1,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));
+#1334=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,1.905));
+#1335=VERTEX_POINT($,#1334);
+#1336=CARTESIAN_POINT($,(65.9207401764197,139.360778771,1.905));
+#1337=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1338=VECTOR($,#1337,1);
+#1339=LINE($,#1336,#1338);
+#1340=EDGE_CURVE($,#1327,#1335,#1339,.T.);
+#1341=ORIENTED_EDGE($,$,$,#1340,.T.);
+#1342=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,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));
+#1344=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,1.905));
+#1345=DIRECTION($,(0.707106781186551,-0.707106781186544,0));
+#1346=VECTOR($,#1345,1);
+#1347=LINE($,#1344,#1346);
+#1348=EDGE_CURVE($,#1335,#1343,#1347,.T.);
+#1349=ORIENTED_EDGE($,$,$,#1348,.T.);
+#1350=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,1.905));
+#1351=VERTEX_POINT($,#1350);
+#1352=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,1.905));
+#1353=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#1354=VECTOR($,#1353,1);
+#1355=LINE($,#1352,#1354);
+#1356=EDGE_CURVE($,#1343,#1351,#1355,.T.);
+#1357=ORIENTED_EDGE($,$,$,#1356,.T.);
+#1358=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,1.905));
+#1359=VERTEX_POINT($,#1358);
+#1360=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,1.905));
+#1361=DIRECTION($,(1,0,0));
+#1362=VECTOR($,#1361,1);
+#1363=LINE($,#1360,#1362);
+#1364=EDGE_CURVE($,#1351,#1359,#1363,.T.);
+#1365=ORIENTED_EDGE($,$,$,#1364,.T.);
+#1366=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,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));
+#1368=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,1.905));
+#1369=DIRECTION($,(0,-1,0));
+#1370=VECTOR($,#1369,1);
+#1371=LINE($,#1368,#1370);
+#1372=EDGE_CURVE($,#1359,#1367,#1371,.T.);
+#1373=ORIENTED_EDGE($,$,$,#1372,.T.);
+#1374=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,1.905));
+#1375=VERTEX_POINT($,#1374);
+#1376=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,1.905));
+#1377=DIRECTION($,(0,-1,0));
+#1378=VECTOR($,#1377,1);
+#1379=LINE($,#1376,#1378);
+#1380=EDGE_CURVE($,#1367,#1375,#1379,.T.);
+#1381=ORIENTED_EDGE($,$,$,#1380,.T.);
+#1382=CARTESIAN_POINT($,(74.1757401764197,53.47972,1.905));
+#1383=VERTEX_POINT($,#1382);
+#1384=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,1.905));
+#1385=DIRECTION($,(0,-1,0));
+#1386=VECTOR($,#1385,1);
+#1387=LINE($,#1384,#1386);
+#1388=EDGE_CURVE($,#1375,#1383,#1387,.T.);
+#1389=ORIENTED_EDGE($,$,$,#1388,.T.);
+#1390=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#1391=VERTEX_POINT($,#1390);
+#1392=CARTESIAN_POINT($,(74.1757401764197,53.47972,1.905));
+#1393=DIRECTION($,(0,-1,0));
+#1394=VECTOR($,#1393,1);
+#1395=LINE($,#1392,#1394);
+#1396=EDGE_CURVE($,#1383,#1391,#1395,.T.);
+#1397=ORIENTED_EDGE($,$,$,#1396,.T.);
+#1398=CARTESIAN_POINT($,(131.32574017642,10,1.905));
+#1399=VERTEX_POINT($,#1398);
+#1400=CARTESIAN_POINT($,(74.1757401764197,10,1.905));
+#1401=DIRECTION($,(1,0,0));
+#1402=VECTOR($,#1401,1);
+#1403=LINE($,#1400,#1402);
+#1404=EDGE_CURVE($,#1391,#1399,#1403,.T.);
+#1405=ORIENTED_EDGE($,$,$,#1404,.T.);
+#1406=CARTESIAN_POINT($,(131.32574017642,35.4,1.905));
+#1407=VERTEX_POINT($,#1406);
+#1408=CARTESIAN_POINT($,(131.32574017642,10,1.905));
+#1409=DIRECTION($,(0,1,0));
+#1410=VECTOR($,#1409,1);
+#1411=LINE($,#1408,#1410);
+#1412=EDGE_CURVE($,#1399,#1407,#1411,.T.);
+#1413=ORIENTED_EDGE($,$,$,#1412,.T.);
+#1414=CARTESIAN_POINT($,(137.67574017642,41.75,1.905));
+#1415=VERTEX_POINT($,#1414);
+#1416=CARTESIAN_POINT($,(131.32574017642,35.4,1.905));
+#1417=DIRECTION($,(0.707106781186547,0.707106781186548,0));
+#1418=VECTOR($,#1417,1);
+#1419=LINE($,#1416,#1418);
+#1420=EDGE_CURVE($,#1407,#1415,#1419,.T.);
+#1421=ORIENTED_EDGE($,$,$,#1420,.T.);
+#1422=CARTESIAN_POINT($,(251.97574017642,41.75,1.905));
+#1423=VERTEX_POINT($,#1422);
+#1424=CARTESIAN_POINT($,(137.67574017642,41.75,1.905));
+#1425=DIRECTION($,(1,0,0));
+#1426=VECTOR($,#1425,1);
+#1427=LINE($,#1424,#1426);
+#1428=EDGE_CURVE($,#1415,#1423,#1427,.T.);
+#1429=ORIENTED_EDGE($,$,$,#1428,.T.);
+#1430=CARTESIAN_POINT($,(258.32574017642,35.4,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));
+#1432=CARTESIAN_POINT($,(251.97574017642,41.75,1.905));
+#1433=DIRECTION($,(0.707106781186547,-0.707106781186548,0));
+#1434=VECTOR($,#1433,1);
+#1435=LINE($,#1432,#1434);
+#1436=EDGE_CURVE($,#1423,#1431,#1435,.T.);
+#1437=ORIENTED_EDGE($,$,$,#1436,.T.);
+#1438=CARTESIAN_POINT($,(258.32574017642,10,1.905));
+#1439=VERTEX_POINT($,#1438);
+#1440=CARTESIAN_POINT($,(258.32574017642,35.4,1.905));
+#1441=DIRECTION($,(0,-1,0));
+#1442=VECTOR($,#1441,1);
+#1443=LINE($,#1440,#1442);
+#1444=EDGE_CURVE($,#1431,#1439,#1443,.T.);
+#1445=ORIENTED_EDGE($,$,$,#1444,.T.);
+#1446=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#1447=VERTEX_POINT($,#1446);
+#1448=CARTESIAN_POINT($,(258.32574017642,10,1.905));
+#1449=DIRECTION($,(1,0,0));
+#1450=VECTOR($,#1449,1);
+#1451=LINE($,#1448,#1450);
+#1452=EDGE_CURVE($,#1439,#1447,#1451,.T.);
+#1453=ORIENTED_EDGE($,$,$,#1452,.T.);
+#1454=CARTESIAN_POINT($,(298.96574017642,53.47972,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));
+#1456=CARTESIAN_POINT($,(298.96574017642,10,1.905));
+#1457=DIRECTION($,(0,1,0));
+#1458=VECTOR($,#1457,1);
+#1459=LINE($,#1456,#1458);
+#1460=EDGE_CURVE($,#1447,#1455,#1459,.T.);
+#1461=ORIENTED_EDGE($,$,$,#1460,.T.);
+#1462=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,1.905));
+#1463=VERTEX_POINT($,#1462);
+#1464=CARTESIAN_POINT($,(298.96574017642,53.47972,1.905));
+#1465=DIRECTION($,(0,1,0));
+#1466=VECTOR($,#1465,1);
+#1467=LINE($,#1464,#1466);
+#1468=EDGE_CURVE($,#1455,#1463,#1467,.T.);
+#1469=ORIENTED_EDGE($,$,$,#1468,.T.);
+#1470=CARTESIAN_POINT($,(298.96574017642,126.54300017642,1.905));
+#1471=VERTEX_POINT($,#1470);
+#1472=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,1.905));
+#1473=DIRECTION($,(0,1,0));
+#1474=VECTOR($,#1473,1);
+#1475=LINE($,#1472,#1474);
+#1476=EDGE_CURVE($,#1463,#1471,#1475,.T.);
+#1477=ORIENTED_EDGE($,$,$,#1476,.T.);
+#1478=CARTESIAN_POINT($,(298.96574017642,138.013740352839,1.905));
+#1479=VERTEX_POINT($,#1478);
+#1480=CARTESIAN_POINT($,(298.96574017642,126.54300017642,1.905));
+#1481=DIRECTION($,(0,1,0));
+#1482=VECTOR($,#1481,1);
+#1483=LINE($,#1480,#1482);
+#1484=EDGE_CURVE($,#1471,#1479,#1483,.T.);
+#1485=ORIENTED_EDGE($,$,$,#1484,.T.);
+#1486=CARTESIAN_POINT($,(305.873701758259,138.013740352839,1.905));
+#1487=VERTEX_POINT($,#1486);
+#1488=CARTESIAN_POINT($,(298.96574017642,138.013740352839,1.905));
+#1489=DIRECTION($,(1,0,0));
+#1490=VECTOR($,#1489,1);
+#1491=LINE($,#1488,#1490);
+#1492=EDGE_CURVE($,#1479,#1487,#1491,.T.);
+#1493=ORIENTED_EDGE($,$,$,#1492,.T.);
+#1494=CARTESIAN_POINT($,(300.710054488645,143.177387622454,1.905));
+#1495=VERTEX_POINT($,#1494);
+#1496=CARTESIAN_POINT($,(305.873701758259,138.013740352839,1.905));
+#1497=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#1498=VECTOR($,#1497,1);
+#1499=LINE($,#1496,#1498);
+#1500=EDGE_CURVE($,#1487,#1495,#1499,.T.);
+#1501=ORIENTED_EDGE($,$,$,#1500,.T.);
+#1502=CARTESIAN_POINT($,(302.057092906805,144.524426040615,1.905));
+#1503=VERTEX_POINT($,#1502);
+#1504=CARTESIAN_POINT($,(300.710054488645,143.177387622454,1.905));
+#1505=DIRECTION($,(0.707106781186548,0.707106781186548,0));
+#1506=VECTOR($,#1505,1);
+#1507=LINE($,#1504,#1506);
+#1508=EDGE_CURVE($,#1495,#1503,#1507,.T.);
+#1509=ORIENTED_EDGE($,$,$,#1508,.T.);
+#1510=CARTESIAN_POINT($,(307.22074017642,139.360778771,1.905));
+#1511=VERTEX_POINT($,#1510);
+#1512=CARTESIAN_POINT($,(302.057092906805,144.524426040615,1.905));
+#1513=DIRECTION($,(0.707106781186549,-0.707106781186546,0));
+#1514=VECTOR($,#1513,1);
+#1515=LINE($,#1512,#1514);
+#1516=EDGE_CURVE($,#1503,#1511,#1515,.T.);
+#1517=ORIENTED_EDGE($,$,$,#1516,.T.);
+#1518=CARTESIAN_POINT($,(307.22074017642,146.268740352839,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));
+#1520=CARTESIAN_POINT($,(307.22074017642,139.360778771,1.905));
+#1521=DIRECTION($,(0,1,0));
+#1522=VECTOR($,#1521,1);
+#1523=LINE($,#1520,#1522);
+#1524=EDGE_CURVE($,#1511,#1519,#1523,.T.);
+#1525=ORIENTED_EDGE($,$,$,#1524,.T.);
+#1526=CARTESIAN_POINT($,(318.691480352839,146.268740352839,1.905));
+#1527=VERTEX_POINT($,#1526);
+#1528=CARTESIAN_POINT($,(307.22074017642,146.268740352839,1.905));
+#1529=DIRECTION($,(1,0,0));
+#1530=VECTOR($,#1529,1);
+#1531=LINE($,#1528,#1530);
+#1532=EDGE_CURVE($,#1519,#1527,#1531,.T.);
+#1533=ORIENTED_EDGE($,$,$,#1532,.T.);
+#1534=CARTESIAN_POINT($,(347.802420352839,146.268740352839,1.905));
+#1535=VERTEX_POINT($,#1534);
+#1536=CARTESIAN_POINT($,(318.691480352839,146.268740352839,1.905));
+#1537=DIRECTION($,(1,0,0));
+#1538=VECTOR($,#1537,1);
+#1539=LINE($,#1536,#1538);
+#1540=EDGE_CURVE($,#1527,#1535,#1539,.T.);
+#1541=ORIENTED_EDGE($,$,$,#1540,.T.);
+#1542=CARTESIAN_POINT($,(347.802420352839,261.051340352839,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.);
+#1544=CARTESIAN_POINT($,(347.802420352839,146.268740352839,1.905));
+#1545=DIRECTION($,(0,1,0));
+#1546=VECTOR($,#1545,1);
+#1547=LINE($,#1544,#1546);
+#1548=EDGE_CURVE($,#1535,#1543,#1547,.T.);
+#1549=ORIENTED_EDGE($,$,$,#1548,.T.);
+#1550=CARTESIAN_POINT($,(353.537790441049,261.051340352839,1.905));
+#1551=VERTEX_POINT($,#1550);
+#1552=CARTESIAN_POINT($,(347.802420352839,261.051340352839,1.905));
+#1553=DIRECTION($,(1,0,0));
+#1554=VECTOR($,#1553,1);
+#1555=LINE($,#1552,#1554);
+#1556=EDGE_CURVE($,#1543,#1551,#1555,.T.);
+#1557=ORIENTED_EDGE($,$,$,#1556,.T.);
+#1558=CARTESIAN_POINT($,(353.537790441049,261.051340352839,1.905));
+#1559=DIRECTION($,(1,0,0));
+#1560=VECTOR($,#1559,1);
+#1561=LINE($,#1558,#1560);
+#1562=EDGE_CURVE($,#1551,#989,#1561,.T.);
+#1563=ORIENTED_EDGE($,$,$,#1562,.T.);
+#1564=EDGE_LOOP($,(#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,#1341,#1349,#1357,#1365,#1373,#1381,#1389,#1397,#1405,#1413,#1421,#1429,#1437,#1445,#1453,#1461,#1469,#1477,#1485,#1493,#1501,#1509,#1517,#1525,#1533,#1541,#1549,#1557,#1563));
+#1565=FACE_OUTER_BOUND('',#1564,.T.);
+#1566=CARTESIAN_POINT($,(277.05824017642,176.700480352839,1.905));
+#1567=VERTEX_POINT($,#1566);
+#1568=CARTESIAN_POINT($,(261.18324017642,176.700480352839,1.905));
+#1569=VERTEX_POINT($,#1568);
+#1570=CARTESIAN_POINT($,(269.12074017642,176.700480352839,1.905));
+#1571=DIRECTION($,(0,0,1));
+#1572=DIRECTION($,(1,0,0));
+#1573=AXIS2_PLACEMENT_3D($,#1570,#1571,#1572);
+#1574=CIRCLE($,#1573,7.9375);
+#1575=TRIMMED_CURVE($,#1574,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1576=EDGE_CURVE($,#1567,#1569,#1575,.T.);
+#1577=ORIENTED_EDGE($,$,$,#1576,.F.);
+#1578=CARTESIAN_POINT($,(269.12074017642,176.700480352839,1.905));
+#1579=DIRECTION($,(0,0,1));
+#1580=DIRECTION($,(1,0,0));
+#1581=AXIS2_PLACEMENT_3D($,#1578,#1579,#1580);
+#1582=CIRCLE($,#1581,7.9375);
+#1583=TRIMMED_CURVE($,#1582,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1584=EDGE_CURVE($,#1569,#1567,#1583,.T.);
+#1585=ORIENTED_EDGE($,$,$,#1584,.F.);
+#1586=EDGE_LOOP($,(#1577,#1585));
+#1587=FACE_BOUND('',#1586,.T.);
+#1588=CARTESIAN_POINT($,(277.05824017642,221.150480352839,1.905));
+#1589=VERTEX_POINT($,#1588);
+#1590=CARTESIAN_POINT($,(261.18324017642,221.150480352839,1.905));
+#1591=VERTEX_POINT($,#1590);
+#1592=CARTESIAN_POINT($,(269.12074017642,221.150480352839,1.905));
+#1593=DIRECTION($,(0,0,1));
+#1594=DIRECTION($,(1,0,0));
+#1595=AXIS2_PLACEMENT_3D($,#1592,#1593,#1594);
+#1596=CIRCLE($,#1595,7.9375);
+#1597=TRIMMED_CURVE($,#1596,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1598=EDGE_CURVE($,#1589,#1591,#1597,.T.);
+#1599=ORIENTED_EDGE($,$,$,#1598,.F.);
+#1600=CARTESIAN_POINT($,(269.12074017642,221.150480352839,1.905));
+#1601=DIRECTION($,(0,0,1));
+#1602=DIRECTION($,(1,0,0));
+#1603=AXIS2_PLACEMENT_3D($,#1600,#1601,#1602);
+#1604=CIRCLE($,#1603,7.9375);
+#1605=TRIMMED_CURVE($,#1604,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1606=EDGE_CURVE($,#1591,#1589,#1605,.T.);
+#1607=ORIENTED_EDGE($,$,$,#1606,.F.);
+#1608=EDGE_LOOP($,(#1599,#1607));
+#1609=FACE_BOUND('',#1608,.T.);
+#1610=CARTESIAN_POINT($,(277.05824017642,265.600480352839,1.905));
+#1611=VERTEX_POINT($,#1610);
+#1612=CARTESIAN_POINT($,(261.18324017642,265.600480352839,1.905));
+#1613=VERTEX_POINT($,#1612);
+#1614=CARTESIAN_POINT($,(269.12074017642,265.600480352839,1.905));
+#1615=DIRECTION($,(0,0,1));
+#1616=DIRECTION($,(1,0,0));
+#1617=AXIS2_PLACEMENT_3D($,#1614,#1615,#1616);
+#1618=CIRCLE($,#1617,7.9375);
+#1619=TRIMMED_CURVE($,#1618,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1620=EDGE_CURVE($,#1611,#1613,#1619,.T.);
+#1621=ORIENTED_EDGE($,$,$,#1620,.F.);
+#1622=CARTESIAN_POINT($,(269.12074017642,265.600480352839,1.905));
+#1623=DIRECTION($,(0,0,1));
+#1624=DIRECTION($,(1,0,0));
+#1625=AXIS2_PLACEMENT_3D($,#1622,#1623,#1624);
+#1626=CIRCLE($,#1625,7.9375);
+#1627=TRIMMED_CURVE($,#1626,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1628=EDGE_CURVE($,#1613,#1611,#1627,.T.);
+#1629=ORIENTED_EDGE($,$,$,#1628,.F.);
+#1630=EDGE_LOOP($,(#1621,#1629));
+#1631=FACE_BOUND('',#1630,.T.);
+#1632=CARTESIAN_POINT($,(277.05824017642,310.050480352839,1.905));
+#1633=VERTEX_POINT($,#1632);
+#1634=CARTESIAN_POINT($,(261.18324017642,310.050480352839,1.905));
+#1635=VERTEX_POINT($,#1634);
+#1636=CARTESIAN_POINT($,(269.12074017642,310.050480352839,1.905));
+#1637=DIRECTION($,(0,0,1));
+#1638=DIRECTION($,(1,0,0));
+#1639=AXIS2_PLACEMENT_3D($,#1636,#1637,#1638);
+#1640=CIRCLE($,#1639,7.9375);
+#1641=TRIMMED_CURVE($,#1640,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1642=EDGE_CURVE($,#1633,#1635,#1641,.T.);
+#1643=ORIENTED_EDGE($,$,$,#1642,.F.);
+#1644=CARTESIAN_POINT($,(269.12074017642,310.050480352839,1.905));
+#1645=DIRECTION($,(0,0,1));
+#1646=DIRECTION($,(1,0,0));
+#1647=AXIS2_PLACEMENT_3D($,#1644,#1645,#1646);
+#1648=CIRCLE($,#1647,7.9375);
+#1649=TRIMMED_CURVE($,#1648,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1650=EDGE_CURVE($,#1635,#1633,#1649,.T.);
+#1651=ORIENTED_EDGE($,$,$,#1650,.F.);
+#1652=EDGE_LOOP($,(#1643,#1651));
+#1653=FACE_BOUND('',#1652,.T.);
+#1654=CARTESIAN_POINT($,(90.5333401764198,29.04746,1.905));
+#1655=VERTEX_POINT($,#1654);
+#1656=CARTESIAN_POINT($,(79.4081401764197,29.04746,1.905));
+#1657=VERTEX_POINT($,#1656);
+#1658=CARTESIAN_POINT($,(84.9707401764198,29.04746,1.905));
+#1659=DIRECTION($,(0,0,1));
+#1660=DIRECTION($,(1,0,0));
+#1661=AXIS2_PLACEMENT_3D($,#1658,#1659,#1660);
+#1662=CIRCLE($,#1661,5.5626);
+#1663=TRIMMED_CURVE($,#1662,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1664=EDGE_CURVE($,#1655,#1657,#1663,.T.);
+#1665=ORIENTED_EDGE($,$,$,#1664,.F.);
+#1666=CARTESIAN_POINT($,(84.9707401764198,29.04746,1.905));
+#1667=DIRECTION($,(0,0,1));
+#1668=DIRECTION($,(1,0,0));
+#1669=AXIS2_PLACEMENT_3D($,#1666,#1667,#1668);
+#1670=CIRCLE($,#1669,5.5626);
+#1671=TRIMMED_CURVE($,#1670,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1672=EDGE_CURVE($,#1657,#1655,#1671,.T.);
+#1673=ORIENTED_EDGE($,$,$,#1672,.F.);
+#1674=EDGE_LOOP($,(#1665,#1673));
+#1675=FACE_BOUND('',#1674,.T.);
+#1676=CARTESIAN_POINT($,(293.73334017642,29.04746,1.905));
+#1677=VERTEX_POINT($,#1676);
+#1678=CARTESIAN_POINT($,(282.60814017642,29.04746,1.905));
+#1679=VERTEX_POINT($,#1678);
+#1680=CARTESIAN_POINT($,(288.17074017642,29.04746,1.905));
+#1681=DIRECTION($,(0,0,1));
+#1682=DIRECTION($,(1,0,0));
+#1683=AXIS2_PLACEMENT_3D($,#1680,#1681,#1682);
+#1684=CIRCLE($,#1683,5.5626);
+#1685=TRIMMED_CURVE($,#1684,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1686=EDGE_CURVE($,#1677,#1679,#1685,.T.);
+#1687=ORIENTED_EDGE($,$,$,#1686,.F.);
+#1688=CARTESIAN_POINT($,(288.17074017642,29.04746,1.905));
+#1689=DIRECTION($,(0,0,1));
+#1690=DIRECTION($,(1,0,0));
+#1691=AXIS2_PLACEMENT_3D($,#1688,#1689,#1690);
+#1692=CIRCLE($,#1691,5.5626);
+#1693=TRIMMED_CURVE($,#1692,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1694=EDGE_CURVE($,#1679,#1677,#1693,.T.);
+#1695=ORIENTED_EDGE($,$,$,#1694,.F.);
+#1696=EDGE_LOOP($,(#1687,#1695));
+#1697=FACE_BOUND('',#1696,.T.);
+#1698=CARTESIAN_POINT($,(263.25334017642,411.447280352839,1.905));
+#1699=VERTEX_POINT($,#1698);
+#1700=CARTESIAN_POINT($,(225.15334017642,411.447280352839,1.905));
+#1701=VERTEX_POINT($,#1700);
+#1702=CARTESIAN_POINT($,(244.20334017642,411.447280352839,1.905));
+#1703=DIRECTION($,(0,0,1));
+#1704=DIRECTION($,(1,0,0));
+#1705=AXIS2_PLACEMENT_3D($,#1702,#1703,#1704);
+#1706=CIRCLE($,#1705,19.05);
+#1707=TRIMMED_CURVE($,#1706,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1708=EDGE_CURVE($,#1699,#1701,#1707,.T.);
+#1709=ORIENTED_EDGE($,$,$,#1708,.F.);
+#1710=CARTESIAN_POINT($,(244.20334017642,411.447280352839,1.905));
+#1711=DIRECTION($,(0,0,1));
+#1712=DIRECTION($,(1,0,0));
+#1713=AXIS2_PLACEMENT_3D($,#1710,#1711,#1712);
+#1714=CIRCLE($,#1713,19.05);
+#1715=TRIMMED_CURVE($,#1714,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1716=EDGE_CURVE($,#1701,#1699,#1715,.T.);
+#1717=ORIENTED_EDGE($,$,$,#1716,.F.);
+#1718=EDGE_LOOP($,(#1709,#1717));
+#1719=FACE_BOUND('',#1718,.T.);
+#1720=CARTESIAN_POINT($,(180.70334017642,436.847280352839,1.905));
+#1721=VERTEX_POINT($,#1720);
+#1722=CARTESIAN_POINT($,(129.90334017642,436.847280352839,1.905));
+#1723=VERTEX_POINT($,#1722);
+#1724=CARTESIAN_POINT($,(155.30334017642,436.847280352839,1.905));
+#1725=DIRECTION($,(0,0,1));
+#1726=DIRECTION($,(1,0,0));
+#1727=AXIS2_PLACEMENT_3D($,#1724,#1725,#1726);
+#1728=CIRCLE($,#1727,25.4);
+#1729=TRIMMED_CURVE($,#1728,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1730=EDGE_CURVE($,#1721,#1723,#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));
+#1732=CARTESIAN_POINT($,(155.30334017642,436.847280352839,1.905));
+#1733=DIRECTION($,(0,0,1));
+#1734=DIRECTION($,(1,0,0));
+#1735=AXIS2_PLACEMENT_3D($,#1732,#1733,#1734);
+#1736=CIRCLE($,#1735,25.4);
+#1737=TRIMMED_CURVE($,#1736,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1738=EDGE_CURVE($,#1723,#1721,#1737,.T.);
+#1739=ORIENTED_EDGE($,$,$,#1738,.F.);
+#1740=EDGE_LOOP($,(#1731,#1739));
+#1741=FACE_BOUND('',#1740,.T.);
+#1742=CARTESIAN_POINT($,(293.73334017642,616.250300705679,1.905));
+#1743=VERTEX_POINT($,#1742);
+#1744=CARTESIAN_POINT($,(282.60814017642,616.250300705679,1.905));
+#1745=VERTEX_POINT($,#1744);
+#1746=CARTESIAN_POINT($,(288.17074017642,616.250300705679,1.905));
+#1747=DIRECTION($,(0,0,1));
+#1748=DIRECTION($,(1,0,0));
+#1749=AXIS2_PLACEMENT_3D($,#1746,#1747,#1748);
+#1750=CIRCLE($,#1749,5.5626);
+#1751=TRIMMED_CURVE($,#1750,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1752=EDGE_CURVE($,#1743,#1745,#1751,.T.);
+#1753=ORIENTED_EDGE($,$,$,#1752,.F.);
+#1754=CARTESIAN_POINT($,(288.17074017642,616.250300705679,1.905));
#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));
+#1756=DIRECTION($,(1,0,0));
+#1757=AXIS2_PLACEMENT_3D($,#1754,#1755,#1756);
+#1758=CIRCLE($,#1757,5.5626);
+#1759=TRIMMED_CURVE($,#1758,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1760=EDGE_CURVE($,#1745,#1743,#1759,.T.);
+#1761=ORIENTED_EDGE($,$,$,#1760,.F.);
+#1762=EDGE_LOOP($,(#1753,#1761));
+#1763=FACE_BOUND('',#1762,.T.);
+#1764=CARTESIAN_POINT($,(90.5333401764198,616.250300705679,1.905));
+#1765=VERTEX_POINT($,#1764);
+#1766=CARTESIAN_POINT($,(79.4081401764197,616.250300705679,1.905));
+#1767=VERTEX_POINT($,#1766);
+#1768=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,1.905));
+#1769=DIRECTION($,(0,0,1));
+#1770=DIRECTION($,(1,0,0));
+#1771=AXIS2_PLACEMENT_3D($,#1768,#1769,#1770);
+#1772=CIRCLE($,#1771,5.5626);
+#1773=TRIMMED_CURVE($,#1772,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1774=EDGE_CURVE($,#1765,#1767,#1773,.T.);
+#1775=ORIENTED_EDGE($,$,$,#1774,.F.);
+#1776=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,1.905));
+#1777=DIRECTION($,(0,0,1));
+#1778=DIRECTION($,(1,0,0));
+#1779=AXIS2_PLACEMENT_3D($,#1776,#1777,#1778);
+#1780=CIRCLE($,#1779,5.5626);
+#1781=TRIMMED_CURVE($,#1780,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1782=EDGE_CURVE($,#1767,#1765,#1781,.T.);
+#1783=ORIENTED_EDGE($,$,$,#1782,.F.);
+#1784=EDGE_LOOP($,(#1775,#1783));
+#1785=FACE_BOUND('',#1784,.T.);
+#1786=CARTESIAN_POINT($,(397.799086493049,324.551340352839,1.905));
+#1787=VERTEX_POINT($,#1786);
+#1788=CARTESIAN_POINT($,(370.748086493049,324.551340352839,1.905));
+#1789=VERTEX_POINT($,#1788);
+#1790=CARTESIAN_POINT($,(384.273586493049,324.551340352839,1.905));
+#1791=DIRECTION($,(0,0,1));
+#1792=DIRECTION($,(1,0,0));
+#1793=AXIS2_PLACEMENT_3D($,#1790,#1791,#1792);
+#1794=CIRCLE($,#1793,13.5255);
+#1795=TRIMMED_CURVE($,#1794,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1796=EDGE_CURVE($,#1787,#1789,#1795,.T.);
+#1797=ORIENTED_EDGE($,$,$,#1796,.F.);
+#1798=CARTESIAN_POINT($,(384.273586493049,324.551340352839,1.905));
#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));
+#1800=DIRECTION($,(1,0,0));
+#1801=AXIS2_PLACEMENT_3D($,#1798,#1799,#1800);
+#1802=CIRCLE($,#1801,13.5255);
+#1803=TRIMMED_CURVE($,#1802,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1804=EDGE_CURVE($,#1789,#1787,#1803,.T.);
+#1805=ORIENTED_EDGE($,$,$,#1804,.F.);
+#1806=EDGE_LOOP($,(#1797,#1805));
+#1807=FACE_BOUND('',#1806,.T.);
+#1808=CARTESIAN_POINT($,(372.684836493049,305.501340352839,1.905));
+#1809=VERTEX_POINT($,#1808);
+#1810=CARTESIAN_POINT($,(367.922336493049,305.501340352839,1.905));
+#1811=VERTEX_POINT($,#1810);
+#1812=CARTESIAN_POINT($,(370.303586493049,305.501340352839,1.905));
+#1813=DIRECTION($,(0,0,1));
+#1814=DIRECTION($,(1,0,0));
+#1815=AXIS2_PLACEMENT_3D($,#1812,#1813,#1814);
+#1816=CIRCLE($,#1815,2.38125);
+#1817=TRIMMED_CURVE($,#1816,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1818=EDGE_CURVE($,#1809,#1811,#1817,.T.);
+#1819=ORIENTED_EDGE($,$,$,#1818,.F.);
+#1820=CARTESIAN_POINT($,(370.303586493049,305.501340352839,1.905));
#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));
+#1822=DIRECTION($,(1,0,0));
+#1823=AXIS2_PLACEMENT_3D($,#1820,#1821,#1822);
+#1824=CIRCLE($,#1823,2.38125);
+#1825=TRIMMED_CURVE($,#1824,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1826=EDGE_CURVE($,#1811,#1809,#1825,.T.);
+#1827=ORIENTED_EDGE($,$,$,#1826,.F.);
+#1828=EDGE_LOOP($,(#1819,#1827));
+#1829=FACE_BOUND('',#1828,.T.);
+#1830=CARTESIAN_POINT($,(372.684836493049,343.601340352839,1.905));
+#1831=VERTEX_POINT($,#1830);
+#1832=CARTESIAN_POINT($,(367.922336493049,343.601340352839,1.905));
+#1833=VERTEX_POINT($,#1832);
+#1834=CARTESIAN_POINT($,(370.303586493049,343.601340352839,1.905));
+#1835=DIRECTION($,(0,0,1));
+#1836=DIRECTION($,(1,0,0));
+#1837=AXIS2_PLACEMENT_3D($,#1834,#1835,#1836);
+#1838=CIRCLE($,#1837,2.38125);
+#1839=TRIMMED_CURVE($,#1838,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1840=EDGE_CURVE($,#1831,#1833,#1839,.T.);
+#1841=ORIENTED_EDGE($,$,$,#1840,.F.);
+#1842=CARTESIAN_POINT($,(370.303586493049,343.601340352839,1.905));
+#1843=DIRECTION($,(0,0,1));
+#1844=DIRECTION($,(1,0,0));
+#1845=AXIS2_PLACEMENT_3D($,#1842,#1843,#1844);
+#1846=CIRCLE($,#1845,2.38125);
+#1847=TRIMMED_CURVE($,#1846,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1848=EDGE_CURVE($,#1833,#1831,#1847,.T.);
+#1849=ORIENTED_EDGE($,$,$,#1848,.F.);
+#1850=EDGE_LOOP($,(#1841,#1849));
+#1851=FACE_BOUND('',#1850,.T.);
+#1852=CARTESIAN_POINT($,(404.434836493049,305.501340352839,1.905));
+#1853=VERTEX_POINT($,#1852);
+#1854=CARTESIAN_POINT($,(399.672336493049,305.501340352839,1.905));
+#1855=VERTEX_POINT($,#1854);
+#1856=CARTESIAN_POINT($,(402.053586493049,305.501340352839,1.905));
+#1857=DIRECTION($,(0,0,1));
+#1858=DIRECTION($,(1,0,0));
+#1859=AXIS2_PLACEMENT_3D($,#1856,#1857,#1858);
+#1860=CIRCLE($,#1859,2.38125);
+#1861=TRIMMED_CURVE($,#1860,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1862=EDGE_CURVE($,#1853,#1855,#1861,.T.);
+#1863=ORIENTED_EDGE($,$,$,#1862,.F.);
+#1864=CARTESIAN_POINT($,(402.053586493049,305.501340352839,1.905));
+#1865=DIRECTION($,(0,0,1));
#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));
+#1867=AXIS2_PLACEMENT_3D($,#1864,#1865,#1866);
+#1868=CIRCLE($,#1867,2.38125);
+#1869=TRIMMED_CURVE($,#1868,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1870=EDGE_CURVE($,#1855,#1853,#1869,.T.);
+#1871=ORIENTED_EDGE($,$,$,#1870,.F.);
+#1872=EDGE_LOOP($,(#1863,#1871));
+#1873=FACE_BOUND('',#1872,.T.);
+#1874=CARTESIAN_POINT($,(404.434836493049,343.601340352839,1.905));
+#1875=VERTEX_POINT($,#1874);
+#1876=CARTESIAN_POINT($,(399.672336493049,343.601340352839,1.905));
+#1877=VERTEX_POINT($,#1876);
+#1878=CARTESIAN_POINT($,(402.053586493049,343.601340352839,1.905));
+#1879=DIRECTION($,(0,0,1));
+#1880=DIRECTION($,(1,0,0));
+#1881=AXIS2_PLACEMENT_3D($,#1878,#1879,#1880);
+#1882=CIRCLE($,#1881,2.38125);
+#1883=TRIMMED_CURVE($,#1882,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(3.14159265358979)),.T.,.PARAMETER.);
+#1884=EDGE_CURVE($,#1875,#1877,#1883,.T.);
+#1885=ORIENTED_EDGE($,$,$,#1884,.F.);
+#1886=CARTESIAN_POINT($,(402.053586493049,343.601340352839,1.905));
+#1887=DIRECTION($,(0,0,1));
+#1888=DIRECTION($,(1,0,0));
+#1889=AXIS2_PLACEMENT_3D($,#1886,#1887,#1888);
+#1890=CIRCLE($,#1889,2.38125);
+#1891=TRIMMED_CURVE($,#1890,(PARAMETER_VALUE(3.14159265358979)),(PARAMETER_VALUE(6.28318530717959)),.T.,.PARAMETER.);
+#1892=EDGE_CURVE($,#1877,#1875,#1891,.T.);
+#1893=ORIENTED_EDGE($,$,$,#1892,.F.);
+#1894=EDGE_LOOP($,(#1885,#1893));
+#1895=FACE_BOUND('',#1894,.T.);
+#1896=CARTESIAN_POINT($,(107.67834017642,201.998880352839,1.905));
+#1897=VERTEX_POINT($,#1896);
+#1898=CARTESIAN_POINT($,(126.72834017642,201.998880352839,1.905));
+#1899=VERTEX_POINT($,#1898);
+#1900=CARTESIAN_POINT($,(107.67834017642,201.998880352839,1.905));
+#1901=DIRECTION($,(1,0,0));
+#1902=VECTOR($,#1901,1);
+#1903=LINE($,#1900,#1902);
+#1904=EDGE_CURVE($,#1897,#1899,#1903,.T.);
+#1905=ORIENTED_EDGE($,$,$,#1904,.F.);
+#1906=CARTESIAN_POINT($,(107.67834017642,290.898880352839,1.905));
+#1907=VERTEX_POINT($,#1906);
+#1908=CARTESIAN_POINT($,(107.67834017642,290.898880352839,1.905));
+#1909=DIRECTION($,(0,-1,0));
+#1910=VECTOR($,#1909,1);
+#1911=LINE($,#1908,#1910);
+#1912=EDGE_CURVE($,#1907,#1897,#1911,.T.);
+#1913=ORIENTED_EDGE($,$,$,#1912,.F.);
+#1914=CARTESIAN_POINT($,(126.72834017642,290.898880352839,1.905));
+#1915=VERTEX_POINT($,#1914);
+#1916=CARTESIAN_POINT($,(126.72834017642,290.898880352839,1.905));
+#1917=DIRECTION($,(-1,0,0));
+#1918=VECTOR($,#1917,1);
+#1919=LINE($,#1916,#1918);
+#1920=EDGE_CURVE($,#1915,#1907,#1919,.T.);
+#1921=ORIENTED_EDGE($,$,$,#1920,.F.);
+#1922=CARTESIAN_POINT($,(126.72834017642,201.998880352839,1.905));
+#1923=DIRECTION($,(0,1,0));
#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));
+#1926=EDGE_CURVE($,#1899,#1915,#1925,.T.);
+#1927=ORIENTED_EDGE($,$,$,#1926,.F.);
+#1928=EDGE_LOOP($,(#1905,#1913,#1921,#1927));
+#1929=FACE_BOUND('',#1928,.T.);
+#1930=CARTESIAN_POINT($,(171.17834017642,201.998880352839,1.905));
+#1931=VERTEX_POINT($,#1930);
+#1932=CARTESIAN_POINT($,(190.22834017642,201.998880352839,1.905));
+#1933=VERTEX_POINT($,#1932);
+#1934=CARTESIAN_POINT($,(171.17834017642,201.998880352839,1.905));
+#1935=DIRECTION($,(1,0,0));
+#1936=VECTOR($,#1935,1);
+#1937=LINE($,#1934,#1936);
+#1938=EDGE_CURVE($,#1931,#1933,#1937,.T.);
+#1939=ORIENTED_EDGE($,$,$,#1938,.F.);
+#1940=CARTESIAN_POINT($,(171.17834017642,290.898880352839,1.905));
+#1941=VERTEX_POINT($,#1940);
+#1942=CARTESIAN_POINT($,(171.17834017642,290.898880352839,1.905));
+#1943=DIRECTION($,(0,-1,0));
+#1944=VECTOR($,#1943,1);
+#1945=LINE($,#1942,#1944);
+#1946=EDGE_CURVE($,#1941,#1931,#1945,.T.);
+#1947=ORIENTED_EDGE($,$,$,#1946,.F.);
+#1948=CARTESIAN_POINT($,(190.22834017642,290.898880352839,1.905));
+#1949=VERTEX_POINT($,#1948);
+#1950=CARTESIAN_POINT($,(190.22834017642,290.898880352839,1.905));
+#1951=DIRECTION($,(-1,0,0));
+#1952=VECTOR($,#1951,1);
+#1953=LINE($,#1950,#1952);
+#1954=EDGE_CURVE($,#1949,#1941,#1953,.T.);
+#1955=ORIENTED_EDGE($,$,$,#1954,.F.);
+#1956=CARTESIAN_POINT($,(190.22834017642,201.998880352839,1.905));
+#1957=DIRECTION($,(0,1,0));
#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);
+#1960=EDGE_CURVE($,#1933,#1949,#1959,.T.);
+#1961=ORIENTED_EDGE($,$,$,#1960,.F.);
+#1962=EDGE_LOOP($,(#1939,#1947,#1955,#1961));
+#1963=FACE_BOUND('',#1962,.T.);
+#1964=ADVANCED_FACE('',(#1565,#1587,#1609,#1631,#1653,#1675,#1697,#1719,#1741,#1763,#1785,#1807,#1829,#1851,#1873,#1895,#1929,#1963),#987,.T.);
+#1965=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#1966=DIRECTION($,(1,0,0));
+#1967=DIRECTION($,(0,0,1));
+#1968=AXIS2_PLACEMENT_3D($,#1965,#1966,#1967);
+#1969=PLANE($,#1968);
+#1970=ORIENTED_EDGE($,$,$,#14,.T.);
+#1971=CARTESIAN_POINT($,(402.051790441049,273.751340352839,0));
+#1972=DIRECTION($,(0,0,1));
+#1973=VECTOR($,#1972,1);
+#1974=LINE($,#1971,#1973);
+#1975=EDGE_CURVE($,#9,#991,#1974,.T.);
+#1976=ORIENTED_EDGE($,$,$,#1975,.T.);
+#1977=ORIENTED_EDGE($,$,$,#996,.F.);
+#1978=CARTESIAN_POINT($,(402.051790441049,261.051340352839,0));
+#1979=DIRECTION($,(0,0,1));
+#1980=VECTOR($,#1979,1);
+#1981=LINE($,#1978,#1980);
+#1982=EDGE_CURVE($,#7,#989,#1981,.T.);
+#1983=ORIENTED_EDGE($,$,$,#1982,.F.);
+#1984=EDGE_LOOP($,(#1970,#1976,#1977,#1983));
+#1985=FACE_OUTER_BOUND('',#1984,.T.);
+#1986=ADVANCED_FACE('',(#1985),#1969,.T.);
+#1987=CARTESIAN_POINT($,(402.051790441049,273.751340352839,0));
+#1988=DIRECTION($,(0,-1,0));
+#1989=DIRECTION($,(0,0,1));
+#1990=AXIS2_PLACEMENT_3D($,#1987,#1988,#1989);
+#1991=PLANE($,#1990);
+#1992=ORIENTED_EDGE($,$,$,#22,.T.);
+#1993=CARTESIAN_POINT($,(414.751790441049,273.751340352839,-0));
+#1994=DIRECTION($,(0,0,1));
+#1995=VECTOR($,#1994,1);
+#1996=LINE($,#1993,#1995);
+#1997=EDGE_CURVE($,#17,#999,#1996,.T.);
+#1998=ORIENTED_EDGE($,$,$,#1997,.T.);
+#1999=ORIENTED_EDGE($,$,$,#1004,.F.);
+#2000=ORIENTED_EDGE($,$,$,#1975,.F.);
+#2001=EDGE_LOOP($,(#1992,#1998,#1999,#2000));
+#2002=FACE_OUTER_BOUND('',#2001,.T.);
+#2003=ADVANCED_FACE('',(#2002),#1991,.T.);
+#2004=CARTESIAN_POINT($,(414.751790441049,273.751340352839,0));
+#2005=DIRECTION($,(1,0,0));
+#2006=DIRECTION($,(0,0,1));
+#2007=AXIS2_PLACEMENT_3D($,#2004,#2005,#2006);
+#2008=PLANE($,#2007);
+#2009=ORIENTED_EDGE($,$,$,#30,.T.);
+#2010=CARTESIAN_POINT($,(414.751790441049,375.351340352839,-0));
+#2011=DIRECTION($,(0,0,1));
+#2012=VECTOR($,#2011,1);
+#2013=LINE($,#2010,#2012);
+#2014=EDGE_CURVE($,#25,#1007,#2013,.T.);
+#2015=ORIENTED_EDGE($,$,$,#2014,.T.);
+#2016=ORIENTED_EDGE($,$,$,#1012,.F.);
+#2017=ORIENTED_EDGE($,$,$,#1997,.F.);
+#2018=EDGE_LOOP($,(#2009,#2015,#2016,#2017));
+#2019=FACE_OUTER_BOUND('',#2018,.T.);
+#2020=ADVANCED_FACE('',(#2019),#2008,.T.);
+#2021=CARTESIAN_POINT($,(414.751790441049,375.351340352839,0));
+#2022=DIRECTION($,(0,1,0));
+#2023=DIRECTION($,(0,0,1));
+#2024=AXIS2_PLACEMENT_3D($,#2021,#2022,#2023);
+#2025=PLANE($,#2024);
+#2026=ORIENTED_EDGE($,$,$,#38,.T.);
+#2027=CARTESIAN_POINT($,(402.051790441049,375.351340352839,0));
+#2028=DIRECTION($,(0,0,1));
+#2029=VECTOR($,#2028,1);
+#2030=LINE($,#2027,#2029);
+#2031=EDGE_CURVE($,#33,#1015,#2030,.T.);
+#2032=ORIENTED_EDGE($,$,$,#2031,.T.);
+#2033=ORIENTED_EDGE($,$,$,#1020,.F.);
+#2034=ORIENTED_EDGE($,$,$,#2014,.F.);
+#2035=EDGE_LOOP($,(#2026,#2032,#2033,#2034));
+#2036=FACE_OUTER_BOUND('',#2035,.T.);
+#2037=ADVANCED_FACE('',(#2036),#2025,.T.);
+#2038=CARTESIAN_POINT($,(402.051790441049,375.351340352839,0));
+#2039=DIRECTION($,(1,0,0));
+#2040=DIRECTION($,(0,0,1));
+#2041=AXIS2_PLACEMENT_3D($,#2038,#2039,#2040);
+#2042=PLANE($,#2041);
+#2043=ORIENTED_EDGE($,$,$,#46,.T.);
+#2044=CARTESIAN_POINT($,(402.051790441049,388.051340352839,-0));
+#2045=DIRECTION($,(0,0,1));
+#2046=VECTOR($,#2045,1);
+#2047=LINE($,#2044,#2046);
+#2048=EDGE_CURVE($,#41,#1023,#2047,.T.);
+#2049=ORIENTED_EDGE($,$,$,#2048,.T.);
+#2050=ORIENTED_EDGE($,$,$,#1028,.F.);
+#2051=ORIENTED_EDGE($,$,$,#2031,.F.);
+#2052=EDGE_LOOP($,(#2043,#2049,#2050,#2051));
+#2053=FACE_OUTER_BOUND('',#2052,.T.);
+#2054=ADVANCED_FACE('',(#2053),#2042,.T.);
+#2055=CARTESIAN_POINT($,(402.051790441049,388.051340352839,0));
+#2056=DIRECTION($,(0,1,0));
+#2057=DIRECTION($,(0,0,1));
+#2058=AXIS2_PLACEMENT_3D($,#2055,#2056,#2057);
+#2059=PLANE($,#2058);
+#2060=ORIENTED_EDGE($,$,$,#54,.T.);
+#2061=CARTESIAN_POINT($,(353.537790441049,388.051340352839,0));
+#2062=DIRECTION($,(0,0,1));
+#2063=VECTOR($,#2062,1);
+#2064=LINE($,#2061,#2063);
+#2065=EDGE_CURVE($,#49,#1031,#2064,.T.);
+#2066=ORIENTED_EDGE($,$,$,#2065,.T.);
+#2067=ORIENTED_EDGE($,$,$,#1036,.F.);
+#2068=ORIENTED_EDGE($,$,$,#2048,.F.);
+#2069=EDGE_LOOP($,(#2060,#2066,#2067,#2068));
+#2070=FACE_OUTER_BOUND('',#2069,.T.);
+#2071=ADVANCED_FACE('',(#2070),#2059,.T.);
+#2072=CARTESIAN_POINT($,(353.537790441049,388.051340352839,0));
+#2073=DIRECTION($,(0,1,0));
+#2074=DIRECTION($,(0,0,1));
+#2075=AXIS2_PLACEMENT_3D($,#2072,#2073,#2074);
+#2076=PLANE($,#2075);
+#2077=ORIENTED_EDGE($,$,$,#62,.T.);
+#2078=CARTESIAN_POINT($,(347.802420352839,388.051340352839,0));
+#2079=DIRECTION($,(0,0,1));
+#2080=VECTOR($,#2079,1);
+#2081=LINE($,#2078,#2080);
+#2082=EDGE_CURVE($,#57,#1039,#2081,.T.);
+#2083=ORIENTED_EDGE($,$,$,#2082,.T.);
+#2084=ORIENTED_EDGE($,$,$,#1044,.F.);
+#2085=ORIENTED_EDGE($,$,$,#2065,.F.);
+#2086=EDGE_LOOP($,(#2077,#2083,#2084,#2085));
+#2087=FACE_OUTER_BOUND('',#2086,.T.);
+#2088=ADVANCED_FACE('',(#2087),#2076,.T.);
+#2089=CARTESIAN_POINT($,(347.802420352839,388.051340352839,0));
+#2090=DIRECTION($,(1,0,0));
+#2091=DIRECTION($,(0,0,1));
+#2092=AXIS2_PLACEMENT_3D($,#2089,#2090,#2091);
+#2093=PLANE($,#2092);
+#2094=ORIENTED_EDGE($,$,$,#70,.T.);
+#2095=CARTESIAN_POINT($,(347.802420352839,498.058740352839,-0));
+#2096=DIRECTION($,(0,0,1));
+#2097=VECTOR($,#2096,1);
+#2098=LINE($,#2095,#2097);
+#2099=EDGE_CURVE($,#65,#1047,#2098,.T.);
+#2100=ORIENTED_EDGE($,$,$,#2099,.T.);
+#2101=ORIENTED_EDGE($,$,$,#1052,.F.);
+#2102=ORIENTED_EDGE($,$,$,#2082,.F.);
+#2103=EDGE_LOOP($,(#2094,#2100,#2101,#2102));
+#2104=FACE_OUTER_BOUND('',#2103,.T.);
+#2105=ADVANCED_FACE('',(#2104),#2093,.T.);
+#2106=CARTESIAN_POINT($,(347.802420352839,498.058740352839,0));
+#2107=DIRECTION($,(0,1,0));
+#2108=DIRECTION($,(0,0,1));
+#2109=AXIS2_PLACEMENT_3D($,#2106,#2107,#2108);
+#2110=PLANE($,#2109);
+#2111=ORIENTED_EDGE($,$,$,#78,.T.);
+#2112=CARTESIAN_POINT($,(318.691480352839,498.058740352839,0));
+#2113=DIRECTION($,(0,0,1));
+#2114=VECTOR($,#2113,1);
+#2115=LINE($,#2112,#2114);
+#2116=EDGE_CURVE($,#73,#1055,#2115,.T.);
+#2117=ORIENTED_EDGE($,$,$,#2116,.T.);
+#2118=ORIENTED_EDGE($,$,$,#1060,.F.);
+#2119=ORIENTED_EDGE($,$,$,#2099,.F.);
+#2120=EDGE_LOOP($,(#2111,#2117,#2118,#2119));
+#2121=FACE_OUTER_BOUND('',#2120,.T.);
+#2122=ADVANCED_FACE('',(#2121),#2110,.T.);
+#2123=CARTESIAN_POINT($,(318.691480352839,498.058740352839,0));
+#2124=DIRECTION($,(0,1,0));
+#2125=DIRECTION($,(0,0,1));
+#2126=AXIS2_PLACEMENT_3D($,#2123,#2124,#2125);
+#2127=PLANE($,#2126);
+#2128=ORIENTED_EDGE($,$,$,#86,.T.);
+#2129=CARTESIAN_POINT($,(307.22074017642,498.058740352839,0));
+#2130=DIRECTION($,(0,0,1));
+#2131=VECTOR($,#2130,1);
+#2132=LINE($,#2129,#2131);
+#2133=EDGE_CURVE($,#81,#1063,#2132,.T.);
+#2134=ORIENTED_EDGE($,$,$,#2133,.T.);
+#2135=ORIENTED_EDGE($,$,$,#1068,.F.);
+#2136=ORIENTED_EDGE($,$,$,#2116,.F.);
+#2137=EDGE_LOOP($,(#2128,#2134,#2135,#2136));
+#2138=FACE_OUTER_BOUND('',#2137,.T.);
+#2139=ADVANCED_FACE('',(#2138),#2127,.T.);
+#2140=CARTESIAN_POINT($,(307.22074017642,498.058740352839,0));
+#2141=DIRECTION($,(1,0,0));
+#2142=DIRECTION($,(0,0,1));
+#2143=AXIS2_PLACEMENT_3D($,#2140,#2141,#2142);
+#2144=PLANE($,#2143);
+#2145=ORIENTED_EDGE($,$,$,#94,.T.);
+#2146=CARTESIAN_POINT($,(307.22074017642,504.966701934679,-0));
+#2147=DIRECTION($,(0,0,1));
+#2148=VECTOR($,#2147,1);
+#2149=LINE($,#2146,#2148);
+#2150=EDGE_CURVE($,#89,#1071,#2149,.T.);
+#2151=ORIENTED_EDGE($,$,$,#2150,.T.);
+#2152=ORIENTED_EDGE($,$,$,#1076,.F.);
+#2153=ORIENTED_EDGE($,$,$,#2133,.F.);
+#2154=EDGE_LOOP($,(#2145,#2151,#2152,#2153));
+#2155=FACE_OUTER_BOUND('',#2154,.T.);
+#2156=ADVANCED_FACE('',(#2155),#2144,.T.);
+#2157=CARTESIAN_POINT($,(307.22074017642,504.966701934679,0));
+#2158=DIRECTION($,(-0.707106781186548,0.707106781186548,0));
+#2159=DIRECTION($,(0,0,1));
+#2160=AXIS2_PLACEMENT_3D($,#2157,#2158,#2159);
+#2161=PLANE($,#2160);
+#2162=ORIENTED_EDGE($,$,$,#102,.T.);
+#2163=CARTESIAN_POINT($,(302.057092906805,499.803054665064,0));
+#2164=DIRECTION($,(0,0,1));
+#2165=VECTOR($,#2164,1);
+#2166=LINE($,#2163,#2165);
+#2167=EDGE_CURVE($,#97,#1079,#2166,.T.);
+#2168=ORIENTED_EDGE($,$,$,#2167,.T.);
+#2169=ORIENTED_EDGE($,$,$,#1084,.F.);
+#2170=ORIENTED_EDGE($,$,$,#2150,.F.);
+#2171=EDGE_LOOP($,(#2162,#2168,#2169,#2170));
+#2172=FACE_OUTER_BOUND('',#2171,.T.);
+#2173=ADVANCED_FACE('',(#2172),#2161,.T.);
+#2174=CARTESIAN_POINT($,(302.057092906805,499.803054665064,0));
+#2175=DIRECTION($,(0.707106781186562,0.707106781186533,0));
+#2176=DIRECTION($,(0,0,1));
+#2177=AXIS2_PLACEMENT_3D($,#2174,#2175,#2176);
+#2178=PLANE($,#2177);
+#2179=ORIENTED_EDGE($,$,$,#110,.T.);
+#2180=CARTESIAN_POINT($,(300.710054488645,501.150093083225,0));
+#2181=DIRECTION($,(0,0,1));
+#2182=VECTOR($,#2181,1);
+#2183=LINE($,#2180,#2182);
+#2184=EDGE_CURVE($,#105,#1087,#2183,.T.);
+#2185=ORIENTED_EDGE($,$,$,#2184,.T.);
+#2186=ORIENTED_EDGE($,$,$,#1092,.F.);
+#2187=ORIENTED_EDGE($,$,$,#2167,.F.);
+#2188=EDGE_LOOP($,(#2179,#2185,#2186,#2187));
+#2189=FACE_OUTER_BOUND('',#2188,.T.);
+#2190=ADVANCED_FACE('',(#2189),#2178,.T.);
+#2191=CARTESIAN_POINT($,(300.710054488645,501.150093083225,0));
+#2192=DIRECTION($,(0.707106781186548,-0.707106781186548,0));
+#2193=DIRECTION($,(0,0,1));
+#2194=AXIS2_PLACEMENT_3D($,#2191,#2192,#2193);
+#2195=PLANE($,#2194);
+#2196=ORIENTED_EDGE($,$,$,#118,.T.);
+#2197=CARTESIAN_POINT($,(305.873701758259,506.313740352839,-0));
+#2198=DIRECTION($,(0,0,1));
+#2199=VECTOR($,#2198,1);
+#2200=LINE($,#2197,#2199);
+#2201=EDGE_CURVE($,#113,#1095,#2200,.T.);
+#2202=ORIENTED_EDGE($,$,$,#2201,.T.);
+#2203=ORIENTED_EDGE($,$,$,#1100,.F.);
+#2204=ORIENTED_EDGE($,$,$,#2184,.F.);
+#2205=EDGE_LOOP($,(#2196,#2202,#2203,#2204));
+#2206=FACE_OUTER_BOUND('',#2205,.T.);
+#2207=ADVANCED_FACE('',(#2206),#2195,.T.);
+#2208=CARTESIAN_POINT($,(305.873701758259,506.313740352839,0));
+#2209=DIRECTION($,(0,1,0));
+#2210=DIRECTION($,(0,0,1));
+#2211=AXIS2_PLACEMENT_3D($,#2208,#2209,#2210);
+#2212=PLANE($,#2211);
+#2213=ORIENTED_EDGE($,$,$,#126,.T.);
+#2214=CARTESIAN_POINT($,(298.96574017642,506.313740352839,0));
+#2215=DIRECTION($,(0,0,1));
+#2216=VECTOR($,#2215,1);
+#2217=LINE($,#2214,#2216);
+#2218=EDGE_CURVE($,#121,#1103,#2217,.T.);
+#2219=ORIENTED_EDGE($,$,$,#2218,.T.);
+#2220=ORIENTED_EDGE($,$,$,#1108,.F.);
+#2221=ORIENTED_EDGE($,$,$,#2201,.F.);
+#2222=EDGE_LOOP($,(#2213,#2219,#2220,#2221));
+#2223=FACE_OUTER_BOUND('',#2222,.T.);
+#2224=ADVANCED_FACE('',(#2223),#2212,.T.);
+#2225=CARTESIAN_POINT($,(298.96574017642,506.313740352839,0));
+#2226=DIRECTION($,(1,0,0));
+#2227=DIRECTION($,(0,0,1));
+#2228=AXIS2_PLACEMENT_3D($,#2225,#2226,#2227);
+#2229=PLANE($,#2228);
+#2230=ORIENTED_EDGE($,$,$,#134,.T.);
+#2231=CARTESIAN_POINT($,(298.96574017642,517.784480529259,0));
+#2232=DIRECTION($,(0,0,1));
+#2233=VECTOR($,#2232,1);
+#2234=LINE($,#2231,#2233);
+#2235=EDGE_CURVE($,#129,#1111,#2234,.T.);
+#2236=ORIENTED_EDGE($,$,$,#2235,.T.);
+#2237=ORIENTED_EDGE($,$,$,#1116,.F.);
+#2238=ORIENTED_EDGE($,$,$,#2218,.F.);
+#2239=EDGE_LOOP($,(#2230,#2236,#2237,#2238));
+#2240=FACE_OUTER_BOUND('',#2239,.T.);
+#2241=ADVANCED_FACE('',(#2240),#2229,.T.);
+#2242=CARTESIAN_POINT($,(298.96574017642,517.784480529259,0));
+#2243=DIRECTION($,(1,0,0));
+#2244=DIRECTION($,(0,0,1));
+#2245=AXIS2_PLACEMENT_3D($,#2242,#2243,#2244);
+#2246=PLANE($,#2245);
+#2247=ORIENTED_EDGE($,$,$,#142,.T.);
+#2248=CARTESIAN_POINT($,(298.96574017642,579.377020529259,0));
+#2249=DIRECTION($,(0,0,1));
+#2250=VECTOR($,#2249,1);
+#2251=LINE($,#2248,#2250);
+#2252=EDGE_CURVE($,#137,#1119,#2251,.T.);
+#2253=ORIENTED_EDGE($,$,$,#2252,.T.);
+#2254=ORIENTED_EDGE($,$,$,#1124,.F.);
+#2255=ORIENTED_EDGE($,$,$,#2235,.F.);
+#2256=EDGE_LOOP($,(#2247,#2253,#2254,#2255));
+#2257=FACE_OUTER_BOUND('',#2256,.T.);
+#2258=ADVANCED_FACE('',(#2257),#2246,.T.);
+#2259=CARTESIAN_POINT($,(298.96574017642,579.377020529259,0));
+#2260=DIRECTION($,(1,0,0));
+#2261=DIRECTION($,(0,0,1));
+#2262=AXIS2_PLACEMENT_3D($,#2259,#2260,#2261);
+#2263=PLANE($,#2262);
+#2264=ORIENTED_EDGE($,$,$,#150,.T.);
+#2265=CARTESIAN_POINT($,(298.96574017642,590.847760705679,0));
+#2266=DIRECTION($,(0,0,1));
+#2267=VECTOR($,#2266,1);
+#2268=LINE($,#2265,#2267);
+#2269=EDGE_CURVE($,#145,#1127,#2268,.T.);
+#2270=ORIENTED_EDGE($,$,$,#2269,.T.);
+#2271=ORIENTED_EDGE($,$,$,#1132,.F.);
+#2272=ORIENTED_EDGE($,$,$,#2252,.F.);
+#2273=EDGE_LOOP($,(#2264,#2270,#2271,#2272));
+#2274=FACE_OUTER_BOUND('',#2273,.T.);
+#2275=ADVANCED_FACE('',(#2274),#2263,.T.);
+#2276=CARTESIAN_POINT($,(298.96574017642,590.847760705679,0));
+#2277=DIRECTION($,(1,0,0));
+#2278=DIRECTION($,(0,0,1));
+#2279=AXIS2_PLACEMENT_3D($,#2276,#2277,#2278);
+#2280=PLANE($,#2279);
+#2281=ORIENTED_EDGE($,$,$,#158,.T.);
+#2282=CARTESIAN_POINT($,(298.96574017642,635.297760705679,-0));
+#2283=DIRECTION($,(0,0,1));
+#2284=VECTOR($,#2283,1);
+#2285=LINE($,#2282,#2284);
+#2286=EDGE_CURVE($,#153,#1135,#2285,.T.);
+#2287=ORIENTED_EDGE($,$,$,#2286,.T.);
+#2288=ORIENTED_EDGE($,$,$,#1140,.F.);
+#2289=ORIENTED_EDGE($,$,$,#2269,.F.);
+#2290=EDGE_LOOP($,(#2281,#2287,#2288,#2289));
+#2291=FACE_OUTER_BOUND('',#2290,.T.);
+#2292=ADVANCED_FACE('',(#2291),#2280,.T.);
+#2293=CARTESIAN_POINT($,(298.96574017642,635.297760705679,0));
+#2294=DIRECTION($,(0,1,0));
+#2295=DIRECTION($,(0,0,1));
+#2296=AXIS2_PLACEMENT_3D($,#2293,#2294,#2295);
+#2297=PLANE($,#2296);
+#2298=ORIENTED_EDGE($,$,$,#166,.T.);
+#2299=CARTESIAN_POINT($,(248.16574017642,635.297760705679,-0));
+#2300=DIRECTION($,(0,0,1));
+#2301=VECTOR($,#2300,1);
+#2302=LINE($,#2299,#2301);
+#2303=EDGE_CURVE($,#161,#1143,#2302,.T.);
+#2304=ORIENTED_EDGE($,$,$,#2303,.T.);
+#2305=ORIENTED_EDGE($,$,$,#1148,.F.);
+#2306=ORIENTED_EDGE($,$,$,#2286,.F.);
+#2307=EDGE_LOOP($,(#2298,#2304,#2305,#2306));
+#2308=FACE_OUTER_BOUND('',#2307,.T.);
+#2309=ADVANCED_FACE('',(#2308),#2297,.T.);
+#2310=CARTESIAN_POINT($,(248.16574017642,635.297760705679,0));
+#2311=DIRECTION($,(-0.707106781186549,0.707106781186546,0));
+#2312=DIRECTION($,(0,0,1));
+#2313=AXIS2_PLACEMENT_3D($,#2310,#2311,#2312);
+#2314=PLANE($,#2313);
+#2315=ORIENTED_EDGE($,$,$,#174,.T.);
+#2316=CARTESIAN_POINT($,(241.81574017642,628.947760705679,-0));
+#2317=DIRECTION($,(0,0,1));
+#2318=VECTOR($,#2317,1);
+#2319=LINE($,#2316,#2318);
+#2320=EDGE_CURVE($,#169,#1151,#2319,.T.);
+#2321=ORIENTED_EDGE($,$,$,#2320,.T.);
+#2322=ORIENTED_EDGE($,$,$,#1156,.F.);
+#2323=ORIENTED_EDGE($,$,$,#2303,.F.);
+#2324=EDGE_LOOP($,(#2315,#2321,#2322,#2323));
+#2325=FACE_OUTER_BOUND('',#2324,.T.);
+#2326=ADVANCED_FACE('',(#2325),#2314,.T.);
+#2327=CARTESIAN_POINT($,(241.81574017642,628.947760705679,0));
+#2328=DIRECTION($,(-1,0,0));
+#2329=DIRECTION($,(0,0,1));
+#2330=AXIS2_PLACEMENT_3D($,#2327,#2328,#2329);
+#2331=PLANE($,#2330);
+#2332=ORIENTED_EDGE($,$,$,#182,.T.);
+#2333=CARTESIAN_POINT($,(241.81574017642,609.897760705679,0));
+#2334=DIRECTION($,(0,0,1));
+#2335=VECTOR($,#2334,1);
+#2336=LINE($,#2333,#2335);
+#2337=EDGE_CURVE($,#177,#1159,#2336,.T.);
+#2338=ORIENTED_EDGE($,$,$,#2337,.T.);
+#2339=ORIENTED_EDGE($,$,$,#1164,.F.);
+#2340=ORIENTED_EDGE($,$,$,#2320,.F.);
+#2341=EDGE_LOOP($,(#2332,#2338,#2339,#2340));
+#2342=FACE_OUTER_BOUND('',#2341,.T.);
+#2343=ADVANCED_FACE('',(#2342),#2331,.T.);
+#2344=CARTESIAN_POINT($,(241.81574017642,609.897760705679,0));
+#2345=DIRECTION($,(-0.707106781186549,0.707106781186546,0));
+#2346=DIRECTION($,(0,0,1));
+#2347=AXIS2_PLACEMENT_3D($,#2344,#2345,#2346);
+#2348=PLANE($,#2347);
+#2349=ORIENTED_EDGE($,$,$,#190,.T.);
+#2350=CARTESIAN_POINT($,(235.46574017642,603.547760705679,0));
+#2351=DIRECTION($,(0,0,1));
+#2352=VECTOR($,#2351,1);
+#2353=LINE($,#2350,#2352);
+#2354=EDGE_CURVE($,#185,#1167,#2353,.T.);
+#2355=ORIENTED_EDGE($,$,$,#2354,.T.);
+#2356=ORIENTED_EDGE($,$,$,#1172,.F.);
+#2357=ORIENTED_EDGE($,$,$,#2337,.F.);
+#2358=EDGE_LOOP($,(#2349,#2355,#2356,#2357));
+#2359=FACE_OUTER_BOUND('',#2358,.T.);
+#2360=ADVANCED_FACE('',(#2359),#2348,.T.);
+#2361=CARTESIAN_POINT($,(235.46574017642,603.547760705679,0));
+#2362=DIRECTION($,(0,1,0));
+#2363=DIRECTION($,(0,0,1));
+#2364=AXIS2_PLACEMENT_3D($,#2361,#2362,#2363);
+#2365=PLANE($,#2364);
+#2366=ORIENTED_EDGE($,$,$,#198,.T.);
+#2367=CARTESIAN_POINT($,(121.16574017642,603.547760705679,0));
+#2368=DIRECTION($,(0,0,1));
+#2369=VECTOR($,#2368,1);
+#2370=LINE($,#2367,#2369);
+#2371=EDGE_CURVE($,#193,#1175,#2370,.T.);
+#2372=ORIENTED_EDGE($,$,$,#2371,.T.);
+#2373=ORIENTED_EDGE($,$,$,#1180,.F.);
+#2374=ORIENTED_EDGE($,$,$,#2354,.F.);
+#2375=EDGE_LOOP($,(#2366,#2372,#2373,#2374));
+#2376=FACE_OUTER_BOUND('',#2375,.T.);
+#2377=ADVANCED_FACE('',(#2376),#2365,.T.);
+#2378=CARTESIAN_POINT($,(121.16574017642,603.547760705679,0));
+#2379=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#2380=DIRECTION($,(0,0,1));
+#2381=AXIS2_PLACEMENT_3D($,#2378,#2379,#2380);
+#2382=PLANE($,#2381);
+#2383=ORIENTED_EDGE($,$,$,#206,.T.);
+#2384=CARTESIAN_POINT($,(114.81574017642,609.897760705679,0));
+#2385=DIRECTION($,(0,0,1));
+#2386=VECTOR($,#2385,1);
+#2387=LINE($,#2384,#2386);
+#2388=EDGE_CURVE($,#201,#1183,#2387,.T.);
+#2389=ORIENTED_EDGE($,$,$,#2388,.T.);
+#2390=ORIENTED_EDGE($,$,$,#1188,.F.);
+#2391=ORIENTED_EDGE($,$,$,#2371,.F.);
+#2392=EDGE_LOOP($,(#2383,#2389,#2390,#2391));
+#2393=FACE_OUTER_BOUND('',#2392,.T.);
+#2394=ADVANCED_FACE('',(#2393),#2382,.T.);
+#2395=CARTESIAN_POINT($,(114.81574017642,609.897760705679,0));
+#2396=DIRECTION($,(1,0,0));
+#2397=DIRECTION($,(0,0,1));
+#2398=AXIS2_PLACEMENT_3D($,#2395,#2396,#2397);
+#2399=PLANE($,#2398);
+#2400=ORIENTED_EDGE($,$,$,#214,.T.);
+#2401=CARTESIAN_POINT($,(114.81574017642,628.947760705679,-0));
+#2402=DIRECTION($,(0,0,1));
+#2403=VECTOR($,#2402,1);
+#2404=LINE($,#2401,#2403);
+#2405=EDGE_CURVE($,#209,#1191,#2404,.T.);
+#2406=ORIENTED_EDGE($,$,$,#2405,.T.);
+#2407=ORIENTED_EDGE($,$,$,#1196,.F.);
+#2408=ORIENTED_EDGE($,$,$,#2388,.F.);
+#2409=EDGE_LOOP($,(#2400,#2406,#2407,#2408));
+#2410=FACE_OUTER_BOUND('',#2409,.T.);
+#2411=ADVANCED_FACE('',(#2410),#2399,.T.);
+#2412=CARTESIAN_POINT($,(114.81574017642,628.947760705679,0));
+#2413=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#2414=DIRECTION($,(0,0,1));
+#2415=AXIS2_PLACEMENT_3D($,#2412,#2413,#2414);
+#2416=PLANE($,#2415);
+#2417=ORIENTED_EDGE($,$,$,#222,.T.);
+#2418=CARTESIAN_POINT($,(108.46574017642,635.297760705679,-0));
+#2419=DIRECTION($,(0,0,1));
+#2420=VECTOR($,#2419,1);
+#2421=LINE($,#2418,#2420);
+#2422=EDGE_CURVE($,#217,#1199,#2421,.T.);
+#2423=ORIENTED_EDGE($,$,$,#2422,.T.);
+#2424=ORIENTED_EDGE($,$,$,#1204,.F.);
+#2425=ORIENTED_EDGE($,$,$,#2405,.F.);
+#2426=EDGE_LOOP($,(#2417,#2423,#2424,#2425));
+#2427=FACE_OUTER_BOUND('',#2426,.T.);
+#2428=ADVANCED_FACE('',(#2427),#2416,.T.);
+#2429=CARTESIAN_POINT($,(108.46574017642,635.297760705679,0));
+#2430=DIRECTION($,(0,1,0));
+#2431=DIRECTION($,(0,0,1));
+#2432=AXIS2_PLACEMENT_3D($,#2429,#2430,#2431);
+#2433=PLANE($,#2432);
+#2434=ORIENTED_EDGE($,$,$,#230,.T.);
+#2435=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,-0));
+#2436=DIRECTION($,(0,0,1));
+#2437=VECTOR($,#2436,1);
+#2438=LINE($,#2435,#2437);
+#2439=EDGE_CURVE($,#225,#1207,#2438,.T.);
+#2440=ORIENTED_EDGE($,$,$,#2439,.T.);
+#2441=ORIENTED_EDGE($,$,$,#1212,.F.);
+#2442=ORIENTED_EDGE($,$,$,#2422,.F.);
+#2443=EDGE_LOOP($,(#2434,#2440,#2441,#2442));
+#2444=FACE_OUTER_BOUND('',#2443,.T.);
+#2445=ADVANCED_FACE('',(#2444),#2433,.T.);
+#2446=CARTESIAN_POINT($,(74.1757401764197,635.297760705679,0));
+#2447=DIRECTION($,(-1,0,0));
+#2448=DIRECTION($,(0,0,1));
+#2449=AXIS2_PLACEMENT_3D($,#2446,#2447,#2448);
+#2450=PLANE($,#2449);
+#2451=ORIENTED_EDGE($,$,$,#238,.T.);
+#2452=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,0));
+#2453=DIRECTION($,(0,0,1));
+#2454=VECTOR($,#2453,1);
+#2455=LINE($,#2452,#2454);
+#2456=EDGE_CURVE($,#233,#1215,#2455,.T.);
+#2457=ORIENTED_EDGE($,$,$,#2456,.T.);
+#2458=ORIENTED_EDGE($,$,$,#1220,.F.);
+#2459=ORIENTED_EDGE($,$,$,#2439,.F.);
+#2460=EDGE_LOOP($,(#2451,#2457,#2458,#2459));
+#2461=FACE_OUTER_BOUND('',#2460,.T.);
+#2462=ADVANCED_FACE('',(#2461),#2450,.T.);
+#2463=CARTESIAN_POINT($,(74.1757401764197,590.847760705679,0));
+#2464=DIRECTION($,(-1,0,0));
+#2465=DIRECTION($,(0,0,1));
+#2466=AXIS2_PLACEMENT_3D($,#2463,#2464,#2465);
+#2467=PLANE($,#2466);
+#2468=ORIENTED_EDGE($,$,$,#246,.T.);
+#2469=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,0));
+#2470=DIRECTION($,(0,0,1));
+#2471=VECTOR($,#2470,1);
+#2472=LINE($,#2469,#2471);
+#2473=EDGE_CURVE($,#241,#1223,#2472,.T.);
+#2474=ORIENTED_EDGE($,$,$,#2473,.T.);
+#2475=ORIENTED_EDGE($,$,$,#1228,.F.);
+#2476=ORIENTED_EDGE($,$,$,#2456,.F.);
+#2477=EDGE_LOOP($,(#2468,#2474,#2475,#2476));
+#2478=FACE_OUTER_BOUND('',#2477,.T.);
+#2479=ADVANCED_FACE('',(#2478),#2467,.T.);
+#2480=CARTESIAN_POINT($,(74.1757401764197,579.377020529259,0));
+#2481=DIRECTION($,(-1,0,0));
+#2482=DIRECTION($,(0,0,1));
+#2483=AXIS2_PLACEMENT_3D($,#2480,#2481,#2482);
+#2484=PLANE($,#2483);
+#2485=ORIENTED_EDGE($,$,$,#254,.T.);
+#2486=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,0));
+#2487=DIRECTION($,(0,0,1));
+#2488=VECTOR($,#2487,1);
+#2489=LINE($,#2486,#2488);
+#2490=EDGE_CURVE($,#249,#1231,#2489,.T.);
+#2491=ORIENTED_EDGE($,$,$,#2490,.T.);
+#2492=ORIENTED_EDGE($,$,$,#1236,.F.);
+#2493=ORIENTED_EDGE($,$,$,#2473,.F.);
+#2494=EDGE_LOOP($,(#2485,#2491,#2492,#2493));
+#2495=FACE_OUTER_BOUND('',#2494,.T.);
+#2496=ADVANCED_FACE('',(#2495),#2484,.T.);
+#2497=CARTESIAN_POINT($,(74.1757401764197,517.784480529259,0));
+#2498=DIRECTION($,(-1,0,0));
+#2499=DIRECTION($,(0,0,1));
+#2500=AXIS2_PLACEMENT_3D($,#2497,#2498,#2499);
+#2501=PLANE($,#2500);
+#2502=ORIENTED_EDGE($,$,$,#262,.T.);
+#2503=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,0));
+#2504=DIRECTION($,(0,0,1));
+#2505=VECTOR($,#2504,1);
+#2506=LINE($,#2503,#2505);
+#2507=EDGE_CURVE($,#257,#1239,#2506,.T.);
+#2508=ORIENTED_EDGE($,$,$,#2507,.T.);
+#2509=ORIENTED_EDGE($,$,$,#1244,.F.);
+#2510=ORIENTED_EDGE($,$,$,#2490,.F.);
+#2511=EDGE_LOOP($,(#2502,#2508,#2509,#2510));
+#2512=FACE_OUTER_BOUND('',#2511,.T.);
+#2513=ADVANCED_FACE('',(#2512),#2501,.T.);
+#2514=CARTESIAN_POINT($,(74.1757401764197,506.313740352839,0));
+#2515=DIRECTION($,(0,1,0));
+#2516=DIRECTION($,(0,0,1));
+#2517=AXIS2_PLACEMENT_3D($,#2514,#2515,#2516);
+#2518=PLANE($,#2517);
+#2519=ORIENTED_EDGE($,$,$,#270,.T.);
+#2520=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,-0));
+#2521=DIRECTION($,(0,0,1));
+#2522=VECTOR($,#2521,1);
+#2523=LINE($,#2520,#2522);
+#2524=EDGE_CURVE($,#265,#1247,#2523,.T.);
+#2525=ORIENTED_EDGE($,$,$,#2524,.T.);
+#2526=ORIENTED_EDGE($,$,$,#1252,.F.);
+#2527=ORIENTED_EDGE($,$,$,#2507,.F.);
+#2528=EDGE_LOOP($,(#2519,#2525,#2526,#2527));
+#2529=FACE_OUTER_BOUND('',#2528,.T.);
+#2530=ADVANCED_FACE('',(#2529),#2518,.T.);
+#2531=CARTESIAN_POINT($,(67.2677785945801,506.313740352839,0));
+#2532=DIRECTION($,(-0.707106781186547,-0.707106781186549,0));
+#2533=DIRECTION($,(0,0,1));
+#2534=AXIS2_PLACEMENT_3D($,#2531,#2532,#2533);
+#2535=PLANE($,#2534);
+#2536=ORIENTED_EDGE($,$,$,#278,.T.);
+#2537=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,0));
+#2538=DIRECTION($,(0,0,1));
+#2539=VECTOR($,#2538,1);
+#2540=LINE($,#2537,#2539);
+#2541=EDGE_CURVE($,#273,#1255,#2540,.T.);
+#2542=ORIENTED_EDGE($,$,$,#2541,.T.);
+#2543=ORIENTED_EDGE($,$,$,#1260,.F.);
+#2544=ORIENTED_EDGE($,$,$,#2524,.F.);
+#2545=EDGE_LOOP($,(#2536,#2542,#2543,#2544));
+#2546=FACE_OUTER_BOUND('',#2545,.T.);
+#2547=ADVANCED_FACE('',(#2546),#2535,.T.);
+#2548=CARTESIAN_POINT($,(72.4314258641949,501.150093083225,0));
+#2549=DIRECTION($,(-0.707106781186559,0.707106781186536,0));
+#2550=DIRECTION($,(0,0,1));
+#2551=AXIS2_PLACEMENT_3D($,#2548,#2549,#2550);
+#2552=PLANE($,#2551);
+#2553=ORIENTED_EDGE($,$,$,#286,.T.);
+#2554=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,0));
+#2555=DIRECTION($,(0,0,1));
+#2556=VECTOR($,#2555,1);
+#2557=LINE($,#2554,#2556);
+#2558=EDGE_CURVE($,#281,#1263,#2557,.T.);
+#2559=ORIENTED_EDGE($,$,$,#2558,.T.);
+#2560=ORIENTED_EDGE($,$,$,#1268,.F.);
+#2561=ORIENTED_EDGE($,$,$,#2541,.F.);
+#2562=EDGE_LOOP($,(#2553,#2559,#2560,#2561));
+#2563=FACE_OUTER_BOUND('',#2562,.T.);
+#2564=ADVANCED_FACE('',(#2563),#2552,.T.);
+#2565=CARTESIAN_POINT($,(71.0843874460345,499.803054665064,0));
+#2566=DIRECTION($,(0.707106781186547,0.707106781186549,0));
+#2567=DIRECTION($,(0,0,1));
+#2568=AXIS2_PLACEMENT_3D($,#2565,#2566,#2567);
+#2569=PLANE($,#2568);
+#2570=ORIENTED_EDGE($,$,$,#294,.T.);
+#2571=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,-0));
+#2572=DIRECTION($,(0,0,1));
+#2573=VECTOR($,#2572,1);
+#2574=LINE($,#2571,#2573);
+#2575=EDGE_CURVE($,#289,#1271,#2574,.T.);
+#2576=ORIENTED_EDGE($,$,$,#2575,.T.);
+#2577=ORIENTED_EDGE($,$,$,#1276,.F.);
+#2578=ORIENTED_EDGE($,$,$,#2558,.F.);
+#2579=EDGE_LOOP($,(#2570,#2576,#2577,#2578));
+#2580=FACE_OUTER_BOUND('',#2579,.T.);
+#2581=ADVANCED_FACE('',(#2580),#2569,.T.);
+#2582=CARTESIAN_POINT($,(65.9207401764197,504.966701934679,0));
+#2583=DIRECTION($,(-1,0,0));
+#2584=DIRECTION($,(0,0,1));
+#2585=AXIS2_PLACEMENT_3D($,#2582,#2583,#2584);
+#2586=PLANE($,#2585);
+#2587=ORIENTED_EDGE($,$,$,#302,.T.);
+#2588=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,0));
+#2589=DIRECTION($,(0,0,1));
+#2590=VECTOR($,#2589,1);
+#2591=LINE($,#2588,#2590);
+#2592=EDGE_CURVE($,#297,#1279,#2591,.T.);
+#2593=ORIENTED_EDGE($,$,$,#2592,.T.);
+#2594=ORIENTED_EDGE($,$,$,#1284,.F.);
+#2595=ORIENTED_EDGE($,$,$,#2575,.F.);
+#2596=EDGE_LOOP($,(#2587,#2593,#2594,#2595));
+#2597=FACE_OUTER_BOUND('',#2596,.T.);
+#2598=ADVANCED_FACE('',(#2597),#2586,.T.);
+#2599=CARTESIAN_POINT($,(65.9207401764197,498.058740352839,0));
+#2600=DIRECTION($,(0,1,0));
+#2601=DIRECTION($,(0,0,1));
+#2602=AXIS2_PLACEMENT_3D($,#2599,#2600,#2601);
+#2603=PLANE($,#2602);
+#2604=ORIENTED_EDGE($,$,$,#310,.T.);
+#2605=CARTESIAN_POINT($,(54.45,498.058740352839,0));
+#2606=DIRECTION($,(0,0,1));
+#2607=VECTOR($,#2606,1);
+#2608=LINE($,#2605,#2607);
+#2609=EDGE_CURVE($,#305,#1287,#2608,.T.);
+#2610=ORIENTED_EDGE($,$,$,#2609,.T.);
+#2611=ORIENTED_EDGE($,$,$,#1292,.F.);
+#2612=ORIENTED_EDGE($,$,$,#2592,.F.);
+#2613=EDGE_LOOP($,(#2604,#2610,#2611,#2612));
+#2614=FACE_OUTER_BOUND('',#2613,.T.);
+#2615=ADVANCED_FACE('',(#2614),#2603,.T.);
+#2616=CARTESIAN_POINT($,(54.45,498.058740352839,0));
+#2617=DIRECTION($,(0,1,0));
+#2618=DIRECTION($,(0,0,1));
+#2619=AXIS2_PLACEMENT_3D($,#2616,#2617,#2618);
+#2620=PLANE($,#2619);
+#2621=ORIENTED_EDGE($,$,$,#318,.T.);
+#2622=CARTESIAN_POINT($,(10,498.058740352839,-0));
+#2623=DIRECTION($,(0,0,1));
+#2624=VECTOR($,#2623,1);
+#2625=LINE($,#2622,#2624);
+#2626=EDGE_CURVE($,#313,#1295,#2625,.T.);
+#2627=ORIENTED_EDGE($,$,$,#2626,.T.);
+#2628=ORIENTED_EDGE($,$,$,#1300,.F.);
+#2629=ORIENTED_EDGE($,$,$,#2609,.F.);
+#2630=EDGE_LOOP($,(#2621,#2627,#2628,#2629));
+#2631=FACE_OUTER_BOUND('',#2630,.T.);
+#2632=ADVANCED_FACE('',(#2631),#2620,.T.);
+#2633=CARTESIAN_POINT($,(10,498.058740352839,0));
+#2634=DIRECTION($,(-1,0,0));
+#2635=DIRECTION($,(0,0,1));
+#2636=AXIS2_PLACEMENT_3D($,#2633,#2634,#2635);
+#2637=PLANE($,#2636);
+#2638=ORIENTED_EDGE($,$,$,#326,.T.);
+#2639=CARTESIAN_POINT($,(10,146.268740352839,-0));
+#2640=DIRECTION($,(0,0,1));
+#2641=VECTOR($,#2640,1);
+#2642=LINE($,#2639,#2641);
+#2643=EDGE_CURVE($,#321,#1303,#2642,.T.);
+#2644=ORIENTED_EDGE($,$,$,#2643,.T.);
+#2645=ORIENTED_EDGE($,$,$,#1308,.F.);
+#2646=ORIENTED_EDGE($,$,$,#2626,.F.);
+#2647=EDGE_LOOP($,(#2638,#2644,#2645,#2646));
+#2648=FACE_OUTER_BOUND('',#2647,.T.);
+#2649=ADVANCED_FACE('',(#2648),#2637,.T.);
+#2650=CARTESIAN_POINT($,(10,146.268740352839,0));
+#2651=DIRECTION($,(0,-1,0));
+#2652=DIRECTION($,(0,0,1));
+#2653=AXIS2_PLACEMENT_3D($,#2650,#2651,#2652);
+#2654=PLANE($,#2653);
+#2655=ORIENTED_EDGE($,$,$,#334,.T.);
+#2656=CARTESIAN_POINT($,(54.45,146.268740352839,0));
+#2657=DIRECTION($,(0,0,1));
+#2658=VECTOR($,#2657,1);
+#2659=LINE($,#2656,#2658);
+#2660=EDGE_CURVE($,#329,#1311,#2659,.T.);
+#2661=ORIENTED_EDGE($,$,$,#2660,.T.);
+#2662=ORIENTED_EDGE($,$,$,#1316,.F.);
+#2663=ORIENTED_EDGE($,$,$,#2643,.F.);
+#2664=EDGE_LOOP($,(#2655,#2661,#2662,#2663));
+#2665=FACE_OUTER_BOUND('',#2664,.T.);
+#2666=ADVANCED_FACE('',(#2665),#2654,.T.);
+#2667=CARTESIAN_POINT($,(54.45,146.268740352839,0));
+#2668=DIRECTION($,(0,-1,0));
+#2669=DIRECTION($,(0,0,1));
+#2670=AXIS2_PLACEMENT_3D($,#2667,#2668,#2669);
+#2671=PLANE($,#2670);
+#2672=ORIENTED_EDGE($,$,$,#342,.T.);
+#2673=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,0));
+#2674=DIRECTION($,(0,0,1));
+#2675=VECTOR($,#2674,1);
+#2676=LINE($,#2673,#2675);
+#2677=EDGE_CURVE($,#337,#1319,#2676,.T.);
+#2678=ORIENTED_EDGE($,$,$,#2677,.T.);
+#2679=ORIENTED_EDGE($,$,$,#1324,.F.);
+#2680=ORIENTED_EDGE($,$,$,#2660,.F.);
+#2681=EDGE_LOOP($,(#2672,#2678,#2679,#2680));
+#2682=FACE_OUTER_BOUND('',#2681,.T.);
+#2683=ADVANCED_FACE('',(#2682),#2671,.T.);
+#2684=CARTESIAN_POINT($,(65.9207401764197,146.268740352839,0));
+#2685=DIRECTION($,(-1,0,0));
+#2686=DIRECTION($,(0,0,1));
+#2687=AXIS2_PLACEMENT_3D($,#2684,#2685,#2686);
+#2688=PLANE($,#2687);
+#2689=ORIENTED_EDGE($,$,$,#350,.T.);
+#2690=CARTESIAN_POINT($,(65.9207401764197,139.360778771,-0));
+#2691=DIRECTION($,(0,0,1));
+#2692=VECTOR($,#2691,1);
+#2693=LINE($,#2690,#2692);
+#2694=EDGE_CURVE($,#345,#1327,#2693,.T.);
+#2695=ORIENTED_EDGE($,$,$,#2694,.T.);
+#2696=ORIENTED_EDGE($,$,$,#1332,.F.);
+#2697=ORIENTED_EDGE($,$,$,#2677,.F.);
+#2698=EDGE_LOOP($,(#2689,#2695,#2696,#2697));
+#2699=FACE_OUTER_BOUND('',#2698,.T.);
+#2700=ADVANCED_FACE('',(#2699),#2688,.T.);
+#2701=CARTESIAN_POINT($,(65.9207401764197,139.360778771,0));
+#2702=DIRECTION($,(0.707106781186547,-0.707106781186547,0));
+#2703=DIRECTION($,(0,0,1));
+#2704=AXIS2_PLACEMENT_3D($,#2701,#2702,#2703);
+#2705=PLANE($,#2704);
+#2706=ORIENTED_EDGE($,$,$,#358,.T.);
+#2707=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,0));
+#2708=DIRECTION($,(0,0,1));
+#2709=VECTOR($,#2708,1);
+#2710=LINE($,#2707,#2709);
+#2711=EDGE_CURVE($,#353,#1335,#2710,.T.);
+#2712=ORIENTED_EDGE($,$,$,#2711,.T.);
+#2713=ORIENTED_EDGE($,$,$,#1340,.F.);
+#2714=ORIENTED_EDGE($,$,$,#2694,.F.);
+#2715=EDGE_LOOP($,(#2706,#2712,#2713,#2714));
+#2716=FACE_OUTER_BOUND('',#2715,.T.);
+#2717=ADVANCED_FACE('',(#2716),#2705,.T.);
+#2718=CARTESIAN_POINT($,(71.0843874460345,144.524426040615,0));
+#2719=DIRECTION($,(-0.707106781186544,-0.707106781186551,0));
+#2720=DIRECTION($,(0,0,1));
+#2721=AXIS2_PLACEMENT_3D($,#2718,#2719,#2720);
+#2722=PLANE($,#2721);
+#2723=ORIENTED_EDGE($,$,$,#366,.T.);
+#2724=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,0));
+#2725=DIRECTION($,(0,0,1));
+#2726=VECTOR($,#2725,1);
+#2727=LINE($,#2724,#2726);
+#2728=EDGE_CURVE($,#361,#1343,#2727,.T.);
+#2729=ORIENTED_EDGE($,$,$,#2728,.T.);
+#2730=ORIENTED_EDGE($,$,$,#1348,.F.);
+#2731=ORIENTED_EDGE($,$,$,#2711,.F.);
+#2732=EDGE_LOOP($,(#2723,#2729,#2730,#2731));
+#2733=FACE_OUTER_BOUND('',#2732,.T.);
+#2734=ADVANCED_FACE('',(#2733),#2722,.T.);
+#2735=CARTESIAN_POINT($,(72.4314258641949,143.177387622454,0));
+#2736=DIRECTION($,(-0.707106781186547,0.707106781186548,0));
+#2737=DIRECTION($,(0,0,1));
+#2738=AXIS2_PLACEMENT_3D($,#2735,#2736,#2737);
+#2739=PLANE($,#2738);
+#2740=ORIENTED_EDGE($,$,$,#374,.T.);
+#2741=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,-0));
+#2742=DIRECTION($,(0,0,1));
+#2743=VECTOR($,#2742,1);
+#2744=LINE($,#2741,#2743);
+#2745=EDGE_CURVE($,#369,#1351,#2744,.T.);
+#2746=ORIENTED_EDGE($,$,$,#2745,.T.);
+#2747=ORIENTED_EDGE($,$,$,#1356,.F.);
+#2748=ORIENTED_EDGE($,$,$,#2728,.F.);
+#2749=EDGE_LOOP($,(#2740,#2746,#2747,#2748));
+#2750=FACE_OUTER_BOUND('',#2749,.T.);
+#2751=ADVANCED_FACE('',(#2750),#2739,.T.);
+#2752=CARTESIAN_POINT($,(67.2677785945801,138.013740352839,0));
+#2753=DIRECTION($,(0,-1,0));
+#2754=DIRECTION($,(0,0,1));
+#2755=AXIS2_PLACEMENT_3D($,#2752,#2753,#2754);
+#2756=PLANE($,#2755);
+#2757=ORIENTED_EDGE($,$,$,#382,.T.);
+#2758=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,0));
+#2759=DIRECTION($,(0,0,1));
+#2760=VECTOR($,#2759,1);
+#2761=LINE($,#2758,#2760);
+#2762=EDGE_CURVE($,#377,#1359,#2761,.T.);
+#2763=ORIENTED_EDGE($,$,$,#2762,.T.);
+#2764=ORIENTED_EDGE($,$,$,#1364,.F.);
+#2765=ORIENTED_EDGE($,$,$,#2745,.F.);
+#2766=EDGE_LOOP($,(#2757,#2763,#2764,#2765));
+#2767=FACE_OUTER_BOUND('',#2766,.T.);
+#2768=ADVANCED_FACE('',(#2767),#2756,.T.);
+#2769=CARTESIAN_POINT($,(74.1757401764197,138.013740352839,0));
+#2770=DIRECTION($,(-1,0,0));
+#2771=DIRECTION($,(0,0,1));
+#2772=AXIS2_PLACEMENT_3D($,#2769,#2770,#2771);
+#2773=PLANE($,#2772);
+#2774=ORIENTED_EDGE($,$,$,#390,.T.);
+#2775=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,0));
+#2776=DIRECTION($,(0,0,1));
+#2777=VECTOR($,#2776,1);
+#2778=LINE($,#2775,#2777);
+#2779=EDGE_CURVE($,#385,#1367,#2778,.T.);
+#2780=ORIENTED_EDGE($,$,$,#2779,.T.);
+#2781=ORIENTED_EDGE($,$,$,#1372,.F.);
+#2782=ORIENTED_EDGE($,$,$,#2762,.F.);
+#2783=EDGE_LOOP($,(#2774,#2780,#2781,#2782));
+#2784=FACE_OUTER_BOUND('',#2783,.T.);
+#2785=ADVANCED_FACE('',(#2784),#2773,.T.);
+#2786=CARTESIAN_POINT($,(74.1757401764197,126.54300017642,0));
+#2787=DIRECTION($,(-1,0,0));
+#2788=DIRECTION($,(0,0,1));
+#2789=AXIS2_PLACEMENT_3D($,#2786,#2787,#2788);
+#2790=PLANE($,#2789);
+#2791=ORIENTED_EDGE($,$,$,#398,.T.);
+#2792=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,0));
+#2793=DIRECTION($,(0,0,1));
+#2794=VECTOR($,#2793,1);
+#2795=LINE($,#2792,#2794);
+#2796=EDGE_CURVE($,#393,#1375,#2795,.T.);
+#2797=ORIENTED_EDGE($,$,$,#2796,.T.);
+#2798=ORIENTED_EDGE($,$,$,#1380,.F.);
+#2799=ORIENTED_EDGE($,$,$,#2779,.F.);
+#2800=EDGE_LOOP($,(#2791,#2797,#2798,#2799));
+#2801=FACE_OUTER_BOUND('',#2800,.T.);
+#2802=ADVANCED_FACE('',(#2801),#2790,.T.);
+#2803=CARTESIAN_POINT($,(74.1757401764197,64.9504601764197,0));
+#2804=DIRECTION($,(-1,0,0));
+#2805=DIRECTION($,(0,0,1));
+#2806=AXIS2_PLACEMENT_3D($,#2803,#2804,#2805);
+#2807=PLANE($,#2806);
+#2808=ORIENTED_EDGE($,$,$,#406,.T.);
+#2809=CARTESIAN_POINT($,(74.1757401764197,53.47972,0));
+#2810=DIRECTION($,(0,0,1));
+#2811=VECTOR($,#2810,1);
+#2812=LINE($,#2809,#2811);
+#2813=EDGE_CURVE($,#401,#1383,#2812,.T.);
+#2814=ORIENTED_EDGE($,$,$,#2813,.T.);
+#2815=ORIENTED_EDGE($,$,$,#1388,.F.);
+#2816=ORIENTED_EDGE($,$,$,#2796,.F.);
+#2817=EDGE_LOOP($,(#2808,#2814,#2815,#2816));
+#2818=FACE_OUTER_BOUND('',#2817,.T.);
+#2819=ADVANCED_FACE('',(#2818),#2807,.T.);
+#2820=CARTESIAN_POINT($,(74.1757401764197,53.47972,0));
+#2821=DIRECTION($,(-1,0,0));
+#2822=DIRECTION($,(0,0,1));
+#2823=AXIS2_PLACEMENT_3D($,#2820,#2821,#2822);
+#2824=PLANE($,#2823);
+#2825=ORIENTED_EDGE($,$,$,#414,.T.);
+#2826=CARTESIAN_POINT($,(74.1757401764197,10,-0));
+#2827=DIRECTION($,(0,0,1));
+#2828=VECTOR($,#2827,1);
+#2829=LINE($,#2826,#2828);
+#2830=EDGE_CURVE($,#409,#1391,#2829,.T.);
+#2831=ORIENTED_EDGE($,$,$,#2830,.T.);
+#2832=ORIENTED_EDGE($,$,$,#1396,.F.);
+#2833=ORIENTED_EDGE($,$,$,#2813,.F.);
+#2834=EDGE_LOOP($,(#2825,#2831,#2832,#2833));
+#2835=FACE_OUTER_BOUND('',#2834,.T.);
+#2836=ADVANCED_FACE('',(#2835),#2824,.T.);
+#2837=CARTESIAN_POINT($,(74.1757401764197,10,0));
+#2838=DIRECTION($,(0,-1,0));
+#2839=DIRECTION($,(0,0,1));
+#2840=AXIS2_PLACEMENT_3D($,#2837,#2838,#2839);
+#2841=PLANE($,#2840);
+#2842=ORIENTED_EDGE($,$,$,#422,.T.);
+#2843=CARTESIAN_POINT($,(131.32574017642,10,-0));
+#2844=DIRECTION($,(0,0,1));
+#2845=VECTOR($,#2844,1);
+#2846=LINE($,#2843,#2845);
+#2847=EDGE_CURVE($,#417,#1399,#2846,.T.);
+#2848=ORIENTED_EDGE($,$,$,#2847,.T.);
+#2849=ORIENTED_EDGE($,$,$,#1404,.F.);
+#2850=ORIENTED_EDGE($,$,$,#2830,.F.);
+#2851=EDGE_LOOP($,(#2842,#2848,#2849,#2850));
+#2852=FACE_OUTER_BOUND('',#2851,.T.);
+#2853=ADVANCED_FACE('',(#2852),#2841,.T.);
+#2854=CARTESIAN_POINT($,(131.32574017642,10,0));
+#2855=DIRECTION($,(1,0,0));
+#2856=DIRECTION($,(0,0,1));
+#2857=AXIS2_PLACEMENT_3D($,#2854,#2855,#2856);
+#2858=PLANE($,#2857);
+#2859=ORIENTED_EDGE($,$,$,#430,.T.);
+#2860=CARTESIAN_POINT($,(131.32574017642,35.4,0));
+#2861=DIRECTION($,(0,0,1));
+#2862=VECTOR($,#2861,1);
+#2863=LINE($,#2860,#2862);
+#2864=EDGE_CURVE($,#425,#1407,#2863,.T.);
+#2865=ORIENTED_EDGE($,$,$,#2864,.T.);
+#2866=ORIENTED_EDGE($,$,$,#1412,.F.);
+#2867=ORIENTED_EDGE($,$,$,#2847,.F.);
+#2868=EDGE_LOOP($,(#2859,#2865,#2866,#2867));
+#2869=FACE_OUTER_BOUND('',#2868,.T.);
+#2870=ADVANCED_FACE('',(#2869),#2858,.T.);
+#2871=CARTESIAN_POINT($,(131.32574017642,35.4,0));
+#2872=DIRECTION($,(0.707106781186548,-0.707106781186547,0));
+#2873=DIRECTION($,(0,0,1));
+#2874=AXIS2_PLACEMENT_3D($,#2871,#2872,#2873);
+#2875=PLANE($,#2874);
+#2876=ORIENTED_EDGE($,$,$,#438,.T.);
+#2877=CARTESIAN_POINT($,(137.67574017642,41.75,0));
+#2878=DIRECTION($,(0,0,1));
+#2879=VECTOR($,#2878,1);
+#2880=LINE($,#2877,#2879);
+#2881=EDGE_CURVE($,#433,#1415,#2880,.T.);
+#2882=ORIENTED_EDGE($,$,$,#2881,.T.);
+#2883=ORIENTED_EDGE($,$,$,#1420,.F.);
+#2884=ORIENTED_EDGE($,$,$,#2864,.F.);
+#2885=EDGE_LOOP($,(#2876,#2882,#2883,#2884));
+#2886=FACE_OUTER_BOUND('',#2885,.T.);
+#2887=ADVANCED_FACE('',(#2886),#2875,.T.);
+#2888=CARTESIAN_POINT($,(137.67574017642,41.75,0));
+#2889=DIRECTION($,(0,-1,0));
+#2890=DIRECTION($,(0,0,1));
+#2891=AXIS2_PLACEMENT_3D($,#2888,#2889,#2890);
+#2892=PLANE($,#2891);
+#2893=ORIENTED_EDGE($,$,$,#446,.T.);
+#2894=CARTESIAN_POINT($,(251.97574017642,41.75,0));
+#2895=DIRECTION($,(0,0,1));
+#2896=VECTOR($,#2895,1);
+#2897=LINE($,#2894,#2896);
+#2898=EDGE_CURVE($,#441,#1423,#2897,.T.);
+#2899=ORIENTED_EDGE($,$,$,#2898,.T.);
+#2900=ORIENTED_EDGE($,$,$,#1428,.F.);
+#2901=ORIENTED_EDGE($,$,$,#2881,.F.);
+#2902=EDGE_LOOP($,(#2893,#2899,#2900,#2901));
+#2903=FACE_OUTER_BOUND('',#2902,.T.);
+#2904=ADVANCED_FACE('',(#2903),#2892,.T.);
+#2905=CARTESIAN_POINT($,(251.97574017642,41.75,0));
+#2906=DIRECTION($,(-0.707106781186548,-0.707106781186547,0));
+#2907=DIRECTION($,(0,0,1));
+#2908=AXIS2_PLACEMENT_3D($,#2905,#2906,#2907);
+#2909=PLANE($,#2908);
+#2910=ORIENTED_EDGE($,$,$,#454,.T.);
+#2911=CARTESIAN_POINT($,(258.32574017642,35.4,0));
+#2912=DIRECTION($,(0,0,1));
+#2913=VECTOR($,#2912,1);
+#2914=LINE($,#2911,#2913);
+#2915=EDGE_CURVE($,#449,#1431,#2914,.T.);
+#2916=ORIENTED_EDGE($,$,$,#2915,.T.);
+#2917=ORIENTED_EDGE($,$,$,#1436,.F.);
+#2918=ORIENTED_EDGE($,$,$,#2898,.F.);
+#2919=EDGE_LOOP($,(#2910,#2916,#2917,#2918));
+#2920=FACE_OUTER_BOUND('',#2919,.T.);
+#2921=ADVANCED_FACE('',(#2920),#2909,.T.);
+#2922=CARTESIAN_POINT($,(258.32574017642,35.4,0));
+#2923=DIRECTION($,(-1,0,0));
+#2924=DIRECTION($,(0,0,1));
+#2925=AXIS2_PLACEMENT_3D($,#2922,#2923,#2924);
+#2926=PLANE($,#2925);
+#2927=ORIENTED_EDGE($,$,$,#462,.T.);
+#2928=CARTESIAN_POINT($,(258.32574017642,10,-0));
+#2929=DIRECTION($,(0,0,1));
+#2930=VECTOR($,#2929,1);
+#2931=LINE($,#2928,#2930);
+#2932=EDGE_CURVE($,#457,#1439,#2931,.T.);
+#2933=ORIENTED_EDGE($,$,$,#2932,.T.);
+#2934=ORIENTED_EDGE($,$,$,#1444,.F.);
+#2935=ORIENTED_EDGE($,$,$,#2915,.F.);
+#2936=EDGE_LOOP($,(#2927,#2933,#2934,#2935));
+#2937=FACE_OUTER_BOUND('',#2936,.T.);
+#2938=ADVANCED_FACE('',(#2937),#2926,.T.);
+#2939=CARTESIAN_POINT($,(258.32574017642,10,0));
+#2940=DIRECTION($,(0,-1,0));
+#2941=DIRECTION($,(0,0,1));
+#2942=AXIS2_PLACEMENT_3D($,#2939,#2940,#2941);
+#2943=PLANE($,#2942);
+#2944=ORIENTED_EDGE($,$,$,#470,.T.);
+#2945=CARTESIAN_POINT($,(298.96574017642,10,-0));
+#2946=DIRECTION($,(0,0,1));
+#2947=VECTOR($,#2946,1);
+#2948=LINE($,#2945,#2947);
+#2949=EDGE_CURVE($,#465,#1447,#2948,.T.);
+#2950=ORIENTED_EDGE($,$,$,#2949,.T.);
+#2951=ORIENTED_EDGE($,$,$,#1452,.F.);
+#2952=ORIENTED_EDGE($,$,$,#2932,.F.);
+#2953=EDGE_LOOP($,(#2944,#2950,#2951,#2952));
+#2954=FACE_OUTER_BOUND('',#2953,.T.);
+#2955=ADVANCED_FACE('',(#2954),#2943,.T.);
+#2956=CARTESIAN_POINT($,(298.96574017642,10,0));
+#2957=DIRECTION($,(1,0,0));
+#2958=DIRECTION($,(0,0,1));
+#2959=AXIS2_PLACEMENT_3D($,#2956,#2957,#2958);
+#2960=PLANE($,#2959);
+#2961=ORIENTED_EDGE($,$,$,#478,.T.);
+#2962=CARTESIAN_POINT($,(298.96574017642,53.47972,0));
+#2963=DIRECTION($,(0,0,1));
+#2964=VECTOR($,#2963,1);
+#2965=LINE($,#2962,#2964);
+#2966=EDGE_CURVE($,#473,#1455,#2965,.T.);
+#2967=ORIENTED_EDGE($,$,$,#2966,.T.);
+#2968=ORIENTED_EDGE($,$,$,#1460,.F.);
+#2969=ORIENTED_EDGE($,$,$,#2949,.F.);
+#2970=EDGE_LOOP($,(#2961,#2967,#2968,#2969));
+#2971=FACE_OUTER_BOUND('',#2970,.T.);
+#2972=ADVANCED_FACE('',(#2971),#2960,.T.);
+#2973=CARTESIAN_POINT($,(298.96574017642,53.47972,0));
+#2974=DIRECTION($,(1,0,0));
+#2975=DIRECTION($,(0,0,1));
+#2976=AXIS2_PLACEMENT_3D($,#2973,#2974,#2975);
+#2977=PLANE($,#2976);
+#2978=ORIENTED_EDGE($,$,$,#486,.T.);
+#2979=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,0));
+#2980=DIRECTION($,(0,0,1));
+#2981=VECTOR($,#2980,1);
+#2982=LINE($,#2979,#2981);
+#2983=EDGE_CURVE($,#481,#1463,#2982,.T.);
+#2984=ORIENTED_EDGE($,$,$,#2983,.T.);
+#2985=ORIENTED_EDGE($,$,$,#1468,.F.);
+#2986=ORIENTED_EDGE($,$,$,#2966,.F.);
+#2987=EDGE_LOOP($,(#2978,#2984,#2985,#2986));
+#2988=FACE_OUTER_BOUND('',#2987,.T.);
+#2989=ADVANCED_FACE('',(#2988),#2977,.T.);
+#2990=CARTESIAN_POINT($,(298.96574017642,64.9504601764197,0));
+#2991=DIRECTION($,(1,0,0));
+#2992=DIRECTION($,(0,0,1));
+#2993=AXIS2_PLACEMENT_3D($,#2990,#2991,#2992);
+#2994=PLANE($,#2993);
+#2995=ORIENTED_EDGE($,$,$,#494,.T.);
+#2996=CARTESIAN_POINT($,(298.96574017642,126.54300017642,0));
+#2997=DIRECTION($,(0,0,1));
+#2998=VECTOR($,#2997,1);
+#2999=LINE($,#2996,#2998);
+#3000=EDGE_CURVE($,#489,#1471,#2999,.T.);
+#3001=ORIENTED_EDGE($,$,$,#3000,.T.);
+#3002=ORIENTED_EDGE($,$,$,#1476,.F.);
+#3003=ORIENTED_EDGE($,$,$,#2983,.F.);
+#3004=EDGE_LOOP($,(#2995,#3001,#3002,#3003));
+#3005=FACE_OUTER_BOUND('',#3004,.T.);
+#3006=ADVANCED_FACE('',(#3005),#2994,.T.);
+#3007=CARTESIAN_POINT($,(298.96574017642,126.54300017642,0));
+#3008=DIRECTION($,(1,0,0));
+#3009=DIRECTION($,(0,0,1));
+#3010=AXIS2_PLACEMENT_3D($,#3007,#3008,#3009);
+#3011=PLANE($,#3010);
+#3012=ORIENTED_EDGE($,$,$,#502,.T.);
+#3013=CARTESIAN_POINT($,(298.96574017642,138.013740352839,0));
+#3014=DIRECTION($,(0,0,1));
+#3015=VECTOR($,#3014,1);
+#3016=LINE($,#3013,#3015);
+#3017=EDGE_CURVE($,#497,#1479,#3016,.T.);
+#3018=ORIENTED_EDGE($,$,$,#3017,.T.);
+#3019=ORIENTED_EDGE($,$,$,#1484,.F.);
+#3020=ORIENTED_EDGE($,$,$,#3000,.F.);
+#3021=EDGE_LOOP($,(#3012,#3018,#3019,#3020));
+#3022=FACE_OUTER_BOUND('',#3021,.T.);
+#3023=ADVANCED_FACE('',(#3022),#3011,.T.);
+#3024=CARTESIAN_POINT($,(298.96574017642,138.013740352839,0));
+#3025=DIRECTION($,(0,-1,0));
+#3026=DIRECTION($,(0,0,1));
+#3027=AXIS2_PLACEMENT_3D($,#3024,#3025,#3026);
+#3028=PLANE($,#3027);
+#3029=ORIENTED_EDGE($,$,$,#510,.T.);
+#3030=CARTESIAN_POINT($,(305.873701758259,138.013740352839,-0));
+#3031=DIRECTION($,(0,0,1));
+#3032=VECTOR($,#3031,1);
+#3033=LINE($,#3030,#3032);
+#3034=EDGE_CURVE($,#505,#1487,#3033,.T.);
+#3035=ORIENTED_EDGE($,$,$,#3034,.T.);
+#3036=ORIENTED_EDGE($,$,$,#1492,.F.);
+#3037=ORIENTED_EDGE($,$,$,#3017,.F.);
+#3038=EDGE_LOOP($,(#3029,#3035,#3036,#3037));
+#3039=FACE_OUTER_BOUND('',#3038,.T.);
+#3040=ADVANCED_FACE('',(#3039),#3028,.T.);
+#3041=CARTESIAN_POINT($,(305.873701758259,138.013740352839,0));
+#3042=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#3043=DIRECTION($,(0,0,1));
+#3044=AXIS2_PLACEMENT_3D($,#3041,#3042,#3043);
+#3045=PLANE($,#3044);
+#3046=ORIENTED_EDGE($,$,$,#518,.T.);
+#3047=CARTESIAN_POINT($,(300.710054488645,143.177387622454,0));
+#3048=DIRECTION($,(0,0,1));
+#3049=VECTOR($,#3048,1);
+#3050=LINE($,#3047,#3049);
+#3051=EDGE_CURVE($,#513,#1495,#3050,.T.);
+#3052=ORIENTED_EDGE($,$,$,#3051,.T.);
+#3053=ORIENTED_EDGE($,$,$,#1500,.F.);
+#3054=ORIENTED_EDGE($,$,$,#3034,.F.);
+#3055=EDGE_LOOP($,(#3046,#3052,#3053,#3054));
+#3056=FACE_OUTER_BOUND('',#3055,.T.);
+#3057=ADVANCED_FACE('',(#3056),#3045,.T.);
+#3058=CARTESIAN_POINT($,(300.710054488645,143.177387622454,0));
+#3059=DIRECTION($,(0.707106781186548,-0.707106781186548,0));
+#3060=DIRECTION($,(0,0,1));
+#3061=AXIS2_PLACEMENT_3D($,#3058,#3059,#3060);
+#3062=PLANE($,#3061);
+#3063=ORIENTED_EDGE($,$,$,#526,.T.);
+#3064=CARTESIAN_POINT($,(302.057092906805,144.524426040615,0));
+#3065=DIRECTION($,(0,0,1));
+#3066=VECTOR($,#3065,1);
+#3067=LINE($,#3064,#3066);
+#3068=EDGE_CURVE($,#521,#1503,#3067,.T.);
+#3069=ORIENTED_EDGE($,$,$,#3068,.T.);
+#3070=ORIENTED_EDGE($,$,$,#1508,.F.);
+#3071=ORIENTED_EDGE($,$,$,#3051,.F.);
+#3072=EDGE_LOOP($,(#3063,#3069,#3070,#3071));
+#3073=FACE_OUTER_BOUND('',#3072,.T.);
+#3074=ADVANCED_FACE('',(#3073),#3062,.T.);
+#3075=CARTESIAN_POINT($,(302.057092906805,144.524426040615,0));
+#3076=DIRECTION($,(-0.707106781186546,-0.707106781186549,0));
+#3077=DIRECTION($,(0,0,1));
+#3078=AXIS2_PLACEMENT_3D($,#3075,#3076,#3077);
+#3079=PLANE($,#3078);
+#3080=ORIENTED_EDGE($,$,$,#534,.T.);
+#3081=CARTESIAN_POINT($,(307.22074017642,139.360778771,-0));
+#3082=DIRECTION($,(0,0,1));
+#3083=VECTOR($,#3082,1);
+#3084=LINE($,#3081,#3083);
+#3085=EDGE_CURVE($,#529,#1511,#3084,.T.);
+#3086=ORIENTED_EDGE($,$,$,#3085,.T.);
+#3087=ORIENTED_EDGE($,$,$,#1516,.F.);
+#3088=ORIENTED_EDGE($,$,$,#3068,.F.);
+#3089=EDGE_LOOP($,(#3080,#3086,#3087,#3088));
+#3090=FACE_OUTER_BOUND('',#3089,.T.);
+#3091=ADVANCED_FACE('',(#3090),#3079,.T.);
+#3092=CARTESIAN_POINT($,(307.22074017642,139.360778771,0));
+#3093=DIRECTION($,(1,0,0));
+#3094=DIRECTION($,(0,0,1));
+#3095=AXIS2_PLACEMENT_3D($,#3092,#3093,#3094);
+#3096=PLANE($,#3095);
+#3097=ORIENTED_EDGE($,$,$,#542,.T.);
+#3098=CARTESIAN_POINT($,(307.22074017642,146.268740352839,0));
+#3099=DIRECTION($,(0,0,1));
+#3100=VECTOR($,#3099,1);
+#3101=LINE($,#3098,#3100);
+#3102=EDGE_CURVE($,#537,#1519,#3101,.T.);
+#3103=ORIENTED_EDGE($,$,$,#3102,.T.);
+#3104=ORIENTED_EDGE($,$,$,#1524,.F.);
+#3105=ORIENTED_EDGE($,$,$,#3085,.F.);
+#3106=EDGE_LOOP($,(#3097,#3103,#3104,#3105));
+#3107=FACE_OUTER_BOUND('',#3106,.T.);
+#3108=ADVANCED_FACE('',(#3107),#3096,.T.);
+#3109=CARTESIAN_POINT($,(307.22074017642,146.268740352839,0));
+#3110=DIRECTION($,(0,-1,0));
+#3111=DIRECTION($,(0,0,1));
+#3112=AXIS2_PLACEMENT_3D($,#3109,#3110,#3111);
+#3113=PLANE($,#3112);
+#3114=ORIENTED_EDGE($,$,$,#550,.T.);
+#3115=CARTESIAN_POINT($,(318.691480352839,146.268740352839,0));
+#3116=DIRECTION($,(0,0,1));
+#3117=VECTOR($,#3116,1);
+#3118=LINE($,#3115,#3117);
+#3119=EDGE_CURVE($,#545,#1527,#3118,.T.);
+#3120=ORIENTED_EDGE($,$,$,#3119,.T.);
+#3121=ORIENTED_EDGE($,$,$,#1532,.F.);
+#3122=ORIENTED_EDGE($,$,$,#3102,.F.);
+#3123=EDGE_LOOP($,(#3114,#3120,#3121,#3122));
+#3124=FACE_OUTER_BOUND('',#3123,.T.);
+#3125=ADVANCED_FACE('',(#3124),#3113,.T.);
+#3126=CARTESIAN_POINT($,(318.691480352839,146.268740352839,0));
+#3127=DIRECTION($,(0,-1,0));
+#3128=DIRECTION($,(0,0,1));
+#3129=AXIS2_PLACEMENT_3D($,#3126,#3127,#3128);
+#3130=PLANE($,#3129);
+#3131=ORIENTED_EDGE($,$,$,#558,.T.);
+#3132=CARTESIAN_POINT($,(347.802420352839,146.268740352839,-0));
+#3133=DIRECTION($,(0,0,1));
+#3134=VECTOR($,#3133,1);
+#3135=LINE($,#3132,#3134);
+#3136=EDGE_CURVE($,#553,#1535,#3135,.T.);
+#3137=ORIENTED_EDGE($,$,$,#3136,.T.);
+#3138=ORIENTED_EDGE($,$,$,#1540,.F.);
+#3139=ORIENTED_EDGE($,$,$,#3119,.F.);
+#3140=EDGE_LOOP($,(#3131,#3137,#3138,#3139));
+#3141=FACE_OUTER_BOUND('',#3140,.T.);
+#3142=ADVANCED_FACE('',(#3141),#3130,.T.);
+#3143=CARTESIAN_POINT($,(347.802420352839,146.268740352839,0));
+#3144=DIRECTION($,(1,0,0));
+#3145=DIRECTION($,(0,0,1));
+#3146=AXIS2_PLACEMENT_3D($,#3143,#3144,#3145);
+#3147=PLANE($,#3146);
+#3148=ORIENTED_EDGE($,$,$,#566,.T.);
+#3149=CARTESIAN_POINT($,(347.802420352839,261.051340352839,0));
+#3150=DIRECTION($,(0,0,1));
+#3151=VECTOR($,#3150,1);
+#3152=LINE($,#3149,#3151);
+#3153=EDGE_CURVE($,#561,#1543,#3152,.T.);
+#3154=ORIENTED_EDGE($,$,$,#3153,.T.);
+#3155=ORIENTED_EDGE($,$,$,#1548,.F.);
+#3156=ORIENTED_EDGE($,$,$,#3136,.F.);
+#3157=EDGE_LOOP($,(#3148,#3154,#3155,#3156));
+#3158=FACE_OUTER_BOUND('',#3157,.T.);
+#3159=ADVANCED_FACE('',(#3158),#3147,.T.);
+#3160=CARTESIAN_POINT($,(347.802420352839,261.051340352839,0));
+#3161=DIRECTION($,(0,-1,0));
+#3162=DIRECTION($,(0,0,1));
+#3163=AXIS2_PLACEMENT_3D($,#3160,#3161,#3162);
+#3164=PLANE($,#3163);
+#3165=ORIENTED_EDGE($,$,$,#574,.T.);
+#3166=CARTESIAN_POINT($,(353.537790441049,261.051340352839,0));
+#3167=DIRECTION($,(0,0,1));
+#3168=VECTOR($,#3167,1);
+#3169=LINE($,#3166,#3168);
+#3170=EDGE_CURVE($,#569,#1551,#3169,.T.);
+#3171=ORIENTED_EDGE($,$,$,#3170,.T.);
+#3172=ORIENTED_EDGE($,$,$,#1556,.F.);
+#3173=ORIENTED_EDGE($,$,$,#3153,.F.);
+#3174=EDGE_LOOP($,(#3165,#3171,#3172,#3173));
+#3175=FACE_OUTER_BOUND('',#3174,.T.);
+#3176=ADVANCED_FACE('',(#3175),#3164,.T.);
+#3177=CARTESIAN_POINT($,(353.537790441049,261.051340352839,0));
+#3178=DIRECTION($,(0,-1,0));
+#3179=DIRECTION($,(0,0,1));
+#3180=AXIS2_PLACEMENT_3D($,#3177,#3178,#3179);
+#3181=PLANE($,#3180);
+#3182=ORIENTED_EDGE($,$,$,#580,.T.);
+#3183=ORIENTED_EDGE($,$,$,#1982,.T.);
+#3184=ORIENTED_EDGE($,$,$,#1562,.F.);
+#3185=ORIENTED_EDGE($,$,$,#3170,.F.);
+#3186=EDGE_LOOP($,(#3182,#3183,#3184,#3185));
+#3187=FACE_OUTER_BOUND('',#3186,.T.);
+#3188=ADVANCED_FACE('',(#3187),#3181,.T.);
+#3189=CARTESIAN_POINT($,(269.12074017642,176.700480352839,0));
+#3190=DIRECTION($,(0,0,1));
+#3191=DIRECTION($,(1,0,0));
+#3192=AXIS2_PLACEMENT_3D($,#3189,#3190,#3191);
+#3193=CYLINDRICAL_SURFACE($,#3192,7.9375);
+#3194=ORIENTED_EDGE($,$,$,#602,.T.);
+#3195=CARTESIAN_POINT($,(277.05824017642,176.700480352839,0));
+#3196=DIRECTION($,(0,0,1));
+#3197=VECTOR($,#3196,1);
+#3198=LINE($,#3195,#3197);
+#3199=EDGE_CURVE($,#585,#1567,#3198,.T.);
+#3200=ORIENTED_EDGE($,$,$,#3199,.T.);
+#3201=ORIENTED_EDGE($,$,$,#1584,.F.);
+#3202=CARTESIAN_POINT($,(261.18324017642,176.700480352839,0));
+#3203=DIRECTION($,(0,0,1));
+#3204=VECTOR($,#3203,1);
+#3205=LINE($,#3202,#3204);
+#3206=EDGE_CURVE($,#587,#1569,#3205,.T.);
+#3207=ORIENTED_EDGE($,$,$,#3206,.F.);
+#3208=EDGE_LOOP($,(#3194,#3200,#3201,#3207));
+#3209=FACE_OUTER_BOUND('',#3208,.T.);
+#3210=ADVANCED_FACE('',(#3209),#3193,.F.);
+#3211=CARTESIAN_POINT($,(269.12074017642,176.700480352839,0));
+#3212=DIRECTION($,(0,0,1));
+#3213=DIRECTION($,(1,0,0));
+#3214=AXIS2_PLACEMENT_3D($,#3211,#3212,#3213);
+#3215=CYLINDRICAL_SURFACE($,#3214,7.9375);
+#3216=ORIENTED_EDGE($,$,$,#594,.T.);
+#3217=ORIENTED_EDGE($,$,$,#3206,.T.);
+#3218=ORIENTED_EDGE($,$,$,#1576,.F.);
+#3219=ORIENTED_EDGE($,$,$,#3199,.F.);
+#3220=EDGE_LOOP($,(#3216,#3217,#3218,#3219));
+#3221=FACE_OUTER_BOUND('',#3220,.T.);
+#3222=ADVANCED_FACE('',(#3221),#3215,.F.);
+#3223=CARTESIAN_POINT($,(269.12074017642,221.150480352839,0));
+#3224=DIRECTION($,(0,0,1));
+#3225=DIRECTION($,(1,0,0));
+#3226=AXIS2_PLACEMENT_3D($,#3223,#3224,#3225);
+#3227=CYLINDRICAL_SURFACE($,#3226,7.9375);
+#3228=ORIENTED_EDGE($,$,$,#624,.T.);
+#3229=CARTESIAN_POINT($,(277.05824017642,221.150480352839,0));
+#3230=DIRECTION($,(0,0,1));
+#3231=VECTOR($,#3230,1);
+#3232=LINE($,#3229,#3231);
+#3233=EDGE_CURVE($,#607,#1589,#3232,.T.);
+#3234=ORIENTED_EDGE($,$,$,#3233,.T.);
+#3235=ORIENTED_EDGE($,$,$,#1606,.F.);
+#3236=CARTESIAN_POINT($,(261.18324017642,221.150480352839,0));
+#3237=DIRECTION($,(0,0,1));
+#3238=VECTOR($,#3237,1);
+#3239=LINE($,#3236,#3238);
+#3240=EDGE_CURVE($,#609,#1591,#3239,.T.);
+#3241=ORIENTED_EDGE($,$,$,#3240,.F.);
+#3242=EDGE_LOOP($,(#3228,#3234,#3235,#3241));
+#3243=FACE_OUTER_BOUND('',#3242,.T.);
+#3244=ADVANCED_FACE('',(#3243),#3227,.F.);
+#3245=CARTESIAN_POINT($,(269.12074017642,221.150480352839,0));
+#3246=DIRECTION($,(0,0,1));
+#3247=DIRECTION($,(1,0,0));
+#3248=AXIS2_PLACEMENT_3D($,#3245,#3246,#3247);
+#3249=CYLINDRICAL_SURFACE($,#3248,7.9375);
+#3250=ORIENTED_EDGE($,$,$,#616,.T.);
+#3251=ORIENTED_EDGE($,$,$,#3240,.T.);
+#3252=ORIENTED_EDGE($,$,$,#1598,.F.);
+#3253=ORIENTED_EDGE($,$,$,#3233,.F.);
+#3254=EDGE_LOOP($,(#3250,#3251,#3252,#3253));
+#3255=FACE_OUTER_BOUND('',#3254,.T.);
+#3256=ADVANCED_FACE('',(#3255),#3249,.F.);
+#3257=CARTESIAN_POINT($,(269.12074017642,265.600480352839,0));
+#3258=DIRECTION($,(0,0,1));
+#3259=DIRECTION($,(1,0,0));
+#3260=AXIS2_PLACEMENT_3D($,#3257,#3258,#3259);
+#3261=CYLINDRICAL_SURFACE($,#3260,7.9375);
+#3262=ORIENTED_EDGE($,$,$,#646,.T.);
+#3263=CARTESIAN_POINT($,(277.05824017642,265.600480352839,0));
+#3264=DIRECTION($,(0,0,1));
+#3265=VECTOR($,#3264,1);
+#3266=LINE($,#3263,#3265);
+#3267=EDGE_CURVE($,#629,#1611,#3266,.T.);
+#3268=ORIENTED_EDGE($,$,$,#3267,.T.);
+#3269=ORIENTED_EDGE($,$,$,#1628,.F.);
+#3270=CARTESIAN_POINT($,(261.18324017642,265.600480352839,0));
+#3271=DIRECTION($,(0,0,1));
+#3272=VECTOR($,#3271,1);
+#3273=LINE($,#3270,#3272);
+#3274=EDGE_CURVE($,#631,#1613,#3273,.T.);
+#3275=ORIENTED_EDGE($,$,$,#3274,.F.);
+#3276=EDGE_LOOP($,(#3262,#3268,#3269,#3275));
+#3277=FACE_OUTER_BOUND('',#3276,.T.);
+#3278=ADVANCED_FACE('',(#3277),#3261,.F.);
+#3279=CARTESIAN_POINT($,(269.12074017642,265.600480352839,0));
+#3280=DIRECTION($,(0,0,1));
+#3281=DIRECTION($,(1,0,0));
+#3282=AXIS2_PLACEMENT_3D($,#3279,#3280,#3281);
+#3283=CYLINDRICAL_SURFACE($,#3282,7.9375);
+#3284=ORIENTED_EDGE($,$,$,#638,.T.);
+#3285=ORIENTED_EDGE($,$,$,#3274,.T.);
+#3286=ORIENTED_EDGE($,$,$,#1620,.F.);
+#3287=ORIENTED_EDGE($,$,$,#3267,.F.);
+#3288=EDGE_LOOP($,(#3284,#3285,#3286,#3287));
+#3289=FACE_OUTER_BOUND('',#3288,.T.);
+#3290=ADVANCED_FACE('',(#3289),#3283,.F.);
+#3291=CARTESIAN_POINT($,(269.12074017642,310.050480352839,0));
+#3292=DIRECTION($,(0,0,1));
+#3293=DIRECTION($,(1,0,0));
+#3294=AXIS2_PLACEMENT_3D($,#3291,#3292,#3293);
+#3295=CYLINDRICAL_SURFACE($,#3294,7.9375);
+#3296=ORIENTED_EDGE($,$,$,#668,.T.);
+#3297=CARTESIAN_POINT($,(277.05824017642,310.050480352839,0));
+#3298=DIRECTION($,(0,0,1));
+#3299=VECTOR($,#3298,1);
+#3300=LINE($,#3297,#3299);
+#3301=EDGE_CURVE($,#651,#1633,#3300,.T.);
+#3302=ORIENTED_EDGE($,$,$,#3301,.T.);
+#3303=ORIENTED_EDGE($,$,$,#1650,.F.);
+#3304=CARTESIAN_POINT($,(261.18324017642,310.050480352839,0));
+#3305=DIRECTION($,(0,0,1));
+#3306=VECTOR($,#3305,1);
+#3307=LINE($,#3304,#3306);
+#3308=EDGE_CURVE($,#653,#1635,#3307,.T.);
+#3309=ORIENTED_EDGE($,$,$,#3308,.F.);
+#3310=EDGE_LOOP($,(#3296,#3302,#3303,#3309));
+#3311=FACE_OUTER_BOUND('',#3310,.T.);
+#3312=ADVANCED_FACE('',(#3311),#3295,.F.);
+#3313=CARTESIAN_POINT($,(269.12074017642,310.050480352839,0));
+#3314=DIRECTION($,(0,0,1));
+#3315=DIRECTION($,(1,0,0));
+#3316=AXIS2_PLACEMENT_3D($,#3313,#3314,#3315);
+#3317=CYLINDRICAL_SURFACE($,#3316,7.9375);
+#3318=ORIENTED_EDGE($,$,$,#660,.T.);
+#3319=ORIENTED_EDGE($,$,$,#3308,.T.);
+#3320=ORIENTED_EDGE($,$,$,#1642,.F.);
+#3321=ORIENTED_EDGE($,$,$,#3301,.F.);
+#3322=EDGE_LOOP($,(#3318,#3319,#3320,#3321));
+#3323=FACE_OUTER_BOUND('',#3322,.T.);
+#3324=ADVANCED_FACE('',(#3323),#3317,.F.);
+#3325=CARTESIAN_POINT($,(84.9707401764198,29.04746,0));
+#3326=DIRECTION($,(0,0,1));
+#3327=DIRECTION($,(1,0,0));
+#3328=AXIS2_PLACEMENT_3D($,#3325,#3326,#3327);
+#3329=CYLINDRICAL_SURFACE($,#3328,5.5626);
+#3330=ORIENTED_EDGE($,$,$,#690,.T.);
+#3331=CARTESIAN_POINT($,(90.5333401764198,29.04746,0));
+#3332=DIRECTION($,(0,0,1));
+#3333=VECTOR($,#3332,1);
+#3334=LINE($,#3331,#3333);
+#3335=EDGE_CURVE($,#673,#1655,#3334,.T.);
+#3336=ORIENTED_EDGE($,$,$,#3335,.T.);
+#3337=ORIENTED_EDGE($,$,$,#1672,.F.);
+#3338=CARTESIAN_POINT($,(79.4081401764197,29.04746,0));
+#3339=DIRECTION($,(0,0,1));
+#3340=VECTOR($,#3339,1);
+#3341=LINE($,#3338,#3340);
+#3342=EDGE_CURVE($,#675,#1657,#3341,.T.);
+#3343=ORIENTED_EDGE($,$,$,#3342,.F.);
+#3344=EDGE_LOOP($,(#3330,#3336,#3337,#3343));
+#3345=FACE_OUTER_BOUND('',#3344,.T.);
+#3346=ADVANCED_FACE('',(#3345),#3329,.F.);
+#3347=CARTESIAN_POINT($,(84.9707401764198,29.04746,0));
+#3348=DIRECTION($,(0,0,1));
+#3349=DIRECTION($,(1,0,0));
+#3350=AXIS2_PLACEMENT_3D($,#3347,#3348,#3349);
+#3351=CYLINDRICAL_SURFACE($,#3350,5.5626);
+#3352=ORIENTED_EDGE($,$,$,#682,.T.);
+#3353=ORIENTED_EDGE($,$,$,#3342,.T.);
+#3354=ORIENTED_EDGE($,$,$,#1664,.F.);
+#3355=ORIENTED_EDGE($,$,$,#3335,.F.);
+#3356=EDGE_LOOP($,(#3352,#3353,#3354,#3355));
+#3357=FACE_OUTER_BOUND('',#3356,.T.);
+#3358=ADVANCED_FACE('',(#3357),#3351,.F.);
+#3359=CARTESIAN_POINT($,(288.17074017642,29.04746,0));
+#3360=DIRECTION($,(0,0,1));
+#3361=DIRECTION($,(1,0,0));
+#3362=AXIS2_PLACEMENT_3D($,#3359,#3360,#3361);
+#3363=CYLINDRICAL_SURFACE($,#3362,5.5626);
+#3364=ORIENTED_EDGE($,$,$,#712,.T.);
+#3365=CARTESIAN_POINT($,(293.73334017642,29.04746,0));
+#3366=DIRECTION($,(0,0,1));
+#3367=VECTOR($,#3366,1);
+#3368=LINE($,#3365,#3367);
+#3369=EDGE_CURVE($,#695,#1677,#3368,.T.);
+#3370=ORIENTED_EDGE($,$,$,#3369,.T.);
+#3371=ORIENTED_EDGE($,$,$,#1694,.F.);
+#3372=CARTESIAN_POINT($,(282.60814017642,29.04746,0));
+#3373=DIRECTION($,(0,0,1));
+#3374=VECTOR($,#3373,1);
+#3375=LINE($,#3372,#3374);
+#3376=EDGE_CURVE($,#697,#1679,#3375,.T.);
+#3377=ORIENTED_EDGE($,$,$,#3376,.F.);
+#3378=EDGE_LOOP($,(#3364,#3370,#3371,#3377));
+#3379=FACE_OUTER_BOUND('',#3378,.T.);
+#3380=ADVANCED_FACE('',(#3379),#3363,.F.);
+#3381=CARTESIAN_POINT($,(288.17074017642,29.04746,0));
+#3382=DIRECTION($,(0,0,1));
+#3383=DIRECTION($,(1,0,0));
+#3384=AXIS2_PLACEMENT_3D($,#3381,#3382,#3383);
+#3385=CYLINDRICAL_SURFACE($,#3384,5.5626);
+#3386=ORIENTED_EDGE($,$,$,#704,.T.);
+#3387=ORIENTED_EDGE($,$,$,#3376,.T.);
+#3388=ORIENTED_EDGE($,$,$,#1686,.F.);
+#3389=ORIENTED_EDGE($,$,$,#3369,.F.);
+#3390=EDGE_LOOP($,(#3386,#3387,#3388,#3389));
+#3391=FACE_OUTER_BOUND('',#3390,.T.);
+#3392=ADVANCED_FACE('',(#3391),#3385,.F.);
+#3393=CARTESIAN_POINT($,(244.20334017642,411.447280352839,0));
+#3394=DIRECTION($,(0,0,1));
+#3395=DIRECTION($,(1,0,0));
+#3396=AXIS2_PLACEMENT_3D($,#3393,#3394,#3395);
+#3397=CYLINDRICAL_SURFACE($,#3396,19.05);
+#3398=ORIENTED_EDGE($,$,$,#734,.T.);
+#3399=CARTESIAN_POINT($,(263.25334017642,411.447280352839,0));
+#3400=DIRECTION($,(0,0,1));
+#3401=VECTOR($,#3400,1);
+#3402=LINE($,#3399,#3401);
+#3403=EDGE_CURVE($,#717,#1699,#3402,.T.);
+#3404=ORIENTED_EDGE($,$,$,#3403,.T.);
+#3405=ORIENTED_EDGE($,$,$,#1716,.F.);
+#3406=CARTESIAN_POINT($,(225.15334017642,411.447280352839,0));
+#3407=DIRECTION($,(0,0,1));
+#3408=VECTOR($,#3407,1);
+#3409=LINE($,#3406,#3408);
+#3410=EDGE_CURVE($,#719,#1701,#3409,.T.);
+#3411=ORIENTED_EDGE($,$,$,#3410,.F.);
+#3412=EDGE_LOOP($,(#3398,#3404,#3405,#3411));
+#3413=FACE_OUTER_BOUND('',#3412,.T.);
+#3414=ADVANCED_FACE('',(#3413),#3397,.F.);
+#3415=CARTESIAN_POINT($,(244.20334017642,411.447280352839,0));
+#3416=DIRECTION($,(0,0,1));
+#3417=DIRECTION($,(1,0,0));
+#3418=AXIS2_PLACEMENT_3D($,#3415,#3416,#3417);
+#3419=CYLINDRICAL_SURFACE($,#3418,19.05);
+#3420=ORIENTED_EDGE($,$,$,#726,.T.);
+#3421=ORIENTED_EDGE($,$,$,#3410,.T.);
+#3422=ORIENTED_EDGE($,$,$,#1708,.F.);
+#3423=ORIENTED_EDGE($,$,$,#3403,.F.);
+#3424=EDGE_LOOP($,(#3420,#3421,#3422,#3423));
+#3425=FACE_OUTER_BOUND('',#3424,.T.);
+#3426=ADVANCED_FACE('',(#3425),#3419,.F.);
+#3427=CARTESIAN_POINT($,(155.30334017642,436.847280352839,0));
+#3428=DIRECTION($,(0,0,1));
+#3429=DIRECTION($,(1,0,0));
+#3430=AXIS2_PLACEMENT_3D($,#3427,#3428,#3429);
+#3431=CYLINDRICAL_SURFACE($,#3430,25.4);
+#3432=ORIENTED_EDGE($,$,$,#756,.T.);
+#3433=CARTESIAN_POINT($,(180.70334017642,436.847280352839,0));
+#3434=DIRECTION($,(0,0,1));
+#3435=VECTOR($,#3434,1);
+#3436=LINE($,#3433,#3435);
+#3437=EDGE_CURVE($,#739,#1721,#3436,.T.);
+#3438=ORIENTED_EDGE($,$,$,#3437,.T.);
+#3439=ORIENTED_EDGE($,$,$,#1738,.F.);
+#3440=CARTESIAN_POINT($,(129.90334017642,436.847280352839,0));
+#3441=DIRECTION($,(0,0,1));
+#3442=VECTOR($,#3441,1);
+#3443=LINE($,#3440,#3442);
+#3444=EDGE_CURVE($,#741,#1723,#3443,.T.);
+#3445=ORIENTED_EDGE($,$,$,#3444,.F.);
+#3446=EDGE_LOOP($,(#3432,#3438,#3439,#3445));
+#3447=FACE_OUTER_BOUND('',#3446,.T.);
+#3448=ADVANCED_FACE('',(#3447),#3431,.F.);
+#3449=CARTESIAN_POINT($,(155.30334017642,436.847280352839,0));
+#3450=DIRECTION($,(0,0,1));
+#3451=DIRECTION($,(1,0,0));
+#3452=AXIS2_PLACEMENT_3D($,#3449,#3450,#3451);
+#3453=CYLINDRICAL_SURFACE($,#3452,25.4);
+#3454=ORIENTED_EDGE($,$,$,#748,.T.);
+#3455=ORIENTED_EDGE($,$,$,#3444,.T.);
+#3456=ORIENTED_EDGE($,$,$,#1730,.F.);
+#3457=ORIENTED_EDGE($,$,$,#3437,.F.);
+#3458=EDGE_LOOP($,(#3454,#3455,#3456,#3457));
+#3459=FACE_OUTER_BOUND('',#3458,.T.);
+#3460=ADVANCED_FACE('',(#3459),#3453,.F.);
+#3461=CARTESIAN_POINT($,(288.17074017642,616.250300705679,0));
+#3462=DIRECTION($,(0,0,1));
+#3463=DIRECTION($,(1,0,0));
+#3464=AXIS2_PLACEMENT_3D($,#3461,#3462,#3463);
+#3465=CYLINDRICAL_SURFACE($,#3464,5.5626);
+#3466=ORIENTED_EDGE($,$,$,#778,.T.);
+#3467=CARTESIAN_POINT($,(293.73334017642,616.250300705679,0));
+#3468=DIRECTION($,(0,0,1));
+#3469=VECTOR($,#3468,1);
+#3470=LINE($,#3467,#3469);
+#3471=EDGE_CURVE($,#761,#1743,#3470,.T.);
+#3472=ORIENTED_EDGE($,$,$,#3471,.T.);
+#3473=ORIENTED_EDGE($,$,$,#1760,.F.);
+#3474=CARTESIAN_POINT($,(282.60814017642,616.250300705679,0));
+#3475=DIRECTION($,(0,0,1));
+#3476=VECTOR($,#3475,1);
+#3477=LINE($,#3474,#3476);
+#3478=EDGE_CURVE($,#763,#1745,#3477,.T.);
+#3479=ORIENTED_EDGE($,$,$,#3478,.F.);
+#3480=EDGE_LOOP($,(#3466,#3472,#3473,#3479));
+#3481=FACE_OUTER_BOUND('',#3480,.T.);
+#3482=ADVANCED_FACE('',(#3481),#3465,.F.);
+#3483=CARTESIAN_POINT($,(288.17074017642,616.250300705679,0));
+#3484=DIRECTION($,(0,0,1));
+#3485=DIRECTION($,(1,0,0));
+#3486=AXIS2_PLACEMENT_3D($,#3483,#3484,#3485);
+#3487=CYLINDRICAL_SURFACE($,#3486,5.5626);
+#3488=ORIENTED_EDGE($,$,$,#770,.T.);
+#3489=ORIENTED_EDGE($,$,$,#3478,.T.);
+#3490=ORIENTED_EDGE($,$,$,#1752,.F.);
+#3491=ORIENTED_EDGE($,$,$,#3471,.F.);
+#3492=EDGE_LOOP($,(#3488,#3489,#3490,#3491));
+#3493=FACE_OUTER_BOUND('',#3492,.T.);
+#3494=ADVANCED_FACE('',(#3493),#3487,.F.);
+#3495=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,0));
+#3496=DIRECTION($,(0,0,1));
+#3497=DIRECTION($,(1,0,0));
+#3498=AXIS2_PLACEMENT_3D($,#3495,#3496,#3497);
+#3499=CYLINDRICAL_SURFACE($,#3498,5.5626);
+#3500=ORIENTED_EDGE($,$,$,#800,.T.);
+#3501=CARTESIAN_POINT($,(90.5333401764198,616.250300705679,0));
+#3502=DIRECTION($,(0,0,1));
+#3503=VECTOR($,#3502,1);
+#3504=LINE($,#3501,#3503);
+#3505=EDGE_CURVE($,#783,#1765,#3504,.T.);
+#3506=ORIENTED_EDGE($,$,$,#3505,.T.);
+#3507=ORIENTED_EDGE($,$,$,#1782,.F.);
+#3508=CARTESIAN_POINT($,(79.4081401764197,616.250300705679,0));
+#3509=DIRECTION($,(0,0,1));
+#3510=VECTOR($,#3509,1);
+#3511=LINE($,#3508,#3510);
+#3512=EDGE_CURVE($,#785,#1767,#3511,.T.);
+#3513=ORIENTED_EDGE($,$,$,#3512,.F.);
+#3514=EDGE_LOOP($,(#3500,#3506,#3507,#3513));
+#3515=FACE_OUTER_BOUND('',#3514,.T.);
+#3516=ADVANCED_FACE('',(#3515),#3499,.F.);
+#3517=CARTESIAN_POINT($,(84.9707401764198,616.250300705679,0));
+#3518=DIRECTION($,(0,0,1));
+#3519=DIRECTION($,(1,0,0));
+#3520=AXIS2_PLACEMENT_3D($,#3517,#3518,#3519);
+#3521=CYLINDRICAL_SURFACE($,#3520,5.5626);
+#3522=ORIENTED_EDGE($,$,$,#792,.T.);
+#3523=ORIENTED_EDGE($,$,$,#3512,.T.);
+#3524=ORIENTED_EDGE($,$,$,#1774,.F.);
+#3525=ORIENTED_EDGE($,$,$,#3505,.F.);
+#3526=EDGE_LOOP($,(#3522,#3523,#3524,#3525));
+#3527=FACE_OUTER_BOUND('',#3526,.T.);
+#3528=ADVANCED_FACE('',(#3527),#3521,.F.);
+#3529=CARTESIAN_POINT($,(384.273586493049,324.551340352839,0));
+#3530=DIRECTION($,(0,0,1));
+#3531=DIRECTION($,(1,0,0));
+#3532=AXIS2_PLACEMENT_3D($,#3529,#3530,#3531);
+#3533=CYLINDRICAL_SURFACE($,#3532,13.5255);
+#3534=ORIENTED_EDGE($,$,$,#822,.T.);
+#3535=CARTESIAN_POINT($,(397.799086493049,324.551340352839,0));
+#3536=DIRECTION($,(0,0,1));
+#3537=VECTOR($,#3536,1);
+#3538=LINE($,#3535,#3537);
+#3539=EDGE_CURVE($,#805,#1787,#3538,.T.);
+#3540=ORIENTED_EDGE($,$,$,#3539,.T.);
+#3541=ORIENTED_EDGE($,$,$,#1804,.F.);
+#3542=CARTESIAN_POINT($,(370.748086493049,324.551340352839,0));
+#3543=DIRECTION($,(0,0,1));
+#3544=VECTOR($,#3543,1);
+#3545=LINE($,#3542,#3544);
+#3546=EDGE_CURVE($,#807,#1789,#3545,.T.);
+#3547=ORIENTED_EDGE($,$,$,#3546,.F.);
+#3548=EDGE_LOOP($,(#3534,#3540,#3541,#3547));
+#3549=FACE_OUTER_BOUND('',#3548,.T.);
+#3550=ADVANCED_FACE('',(#3549),#3533,.F.);
+#3551=CARTESIAN_POINT($,(384.273586493049,324.551340352839,0));
+#3552=DIRECTION($,(0,0,1));
+#3553=DIRECTION($,(1,0,0));
+#3554=AXIS2_PLACEMENT_3D($,#3551,#3552,#3553);
+#3555=CYLINDRICAL_SURFACE($,#3554,13.5255);
+#3556=ORIENTED_EDGE($,$,$,#814,.T.);
+#3557=ORIENTED_EDGE($,$,$,#3546,.T.);
+#3558=ORIENTED_EDGE($,$,$,#1796,.F.);
+#3559=ORIENTED_EDGE($,$,$,#3539,.F.);
+#3560=EDGE_LOOP($,(#3556,#3557,#3558,#3559));
+#3561=FACE_OUTER_BOUND('',#3560,.T.);
+#3562=ADVANCED_FACE('',(#3561),#3555,.F.);
+#3563=CARTESIAN_POINT($,(370.303586493049,305.501340352839,0));
+#3564=DIRECTION($,(0,0,1));
+#3565=DIRECTION($,(1,0,0));
+#3566=AXIS2_PLACEMENT_3D($,#3563,#3564,#3565);
+#3567=CYLINDRICAL_SURFACE($,#3566,2.38125);
+#3568=ORIENTED_EDGE($,$,$,#844,.T.);
+#3569=CARTESIAN_POINT($,(372.684836493049,305.501340352839,0));
+#3570=DIRECTION($,(0,0,1));
+#3571=VECTOR($,#3570,1);
+#3572=LINE($,#3569,#3571);
+#3573=EDGE_CURVE($,#827,#1809,#3572,.T.);
+#3574=ORIENTED_EDGE($,$,$,#3573,.T.);
+#3575=ORIENTED_EDGE($,$,$,#1826,.F.);
+#3576=CARTESIAN_POINT($,(367.922336493049,305.501340352839,0));
+#3577=DIRECTION($,(0,0,1));
+#3578=VECTOR($,#3577,1);
+#3579=LINE($,#3576,#3578);
+#3580=EDGE_CURVE($,#829,#1811,#3579,.T.);
+#3581=ORIENTED_EDGE($,$,$,#3580,.F.);
+#3582=EDGE_LOOP($,(#3568,#3574,#3575,#3581));
+#3583=FACE_OUTER_BOUND('',#3582,.T.);
+#3584=ADVANCED_FACE('',(#3583),#3567,.F.);
+#3585=CARTESIAN_POINT($,(370.303586493049,305.501340352839,0));
+#3586=DIRECTION($,(0,0,1));
+#3587=DIRECTION($,(1,0,0));
+#3588=AXIS2_PLACEMENT_3D($,#3585,#3586,#3587);
+#3589=CYLINDRICAL_SURFACE($,#3588,2.38125);
+#3590=ORIENTED_EDGE($,$,$,#836,.T.);
+#3591=ORIENTED_EDGE($,$,$,#3580,.T.);
+#3592=ORIENTED_EDGE($,$,$,#1818,.F.);
+#3593=ORIENTED_EDGE($,$,$,#3573,.F.);
+#3594=EDGE_LOOP($,(#3590,#3591,#3592,#3593));
+#3595=FACE_OUTER_BOUND('',#3594,.T.);
+#3596=ADVANCED_FACE('',(#3595),#3589,.F.);
+#3597=CARTESIAN_POINT($,(370.303586493049,343.601340352839,0));
+#3598=DIRECTION($,(0,0,1));
+#3599=DIRECTION($,(1,0,0));
+#3600=AXIS2_PLACEMENT_3D($,#3597,#3598,#3599);
+#3601=CYLINDRICAL_SURFACE($,#3600,2.38125);
+#3602=ORIENTED_EDGE($,$,$,#866,.T.);
+#3603=CARTESIAN_POINT($,(372.684836493049,343.601340352839,0));
+#3604=DIRECTION($,(0,0,1));
+#3605=VECTOR($,#3604,1);
+#3606=LINE($,#3603,#3605);
+#3607=EDGE_CURVE($,#849,#1831,#3606,.T.);
+#3608=ORIENTED_EDGE($,$,$,#3607,.T.);
+#3609=ORIENTED_EDGE($,$,$,#1848,.F.);
+#3610=CARTESIAN_POINT($,(367.922336493049,343.601340352839,0));
+#3611=DIRECTION($,(0,0,1));
+#3612=VECTOR($,#3611,1);
+#3613=LINE($,#3610,#3612);
+#3614=EDGE_CURVE($,#851,#1833,#3613,.T.);
+#3615=ORIENTED_EDGE($,$,$,#3614,.F.);
+#3616=EDGE_LOOP($,(#3602,#3608,#3609,#3615));
+#3617=FACE_OUTER_BOUND('',#3616,.T.);
+#3618=ADVANCED_FACE('',(#3617),#3601,.F.);
+#3619=CARTESIAN_POINT($,(370.303586493049,343.601340352839,0));
+#3620=DIRECTION($,(0,0,1));
+#3621=DIRECTION($,(1,0,0));
+#3622=AXIS2_PLACEMENT_3D($,#3619,#3620,#3621);
+#3623=CYLINDRICAL_SURFACE($,#3622,2.38125);
+#3624=ORIENTED_EDGE($,$,$,#858,.T.);
+#3625=ORIENTED_EDGE($,$,$,#3614,.T.);
+#3626=ORIENTED_EDGE($,$,$,#1840,.F.);
+#3627=ORIENTED_EDGE($,$,$,#3607,.F.);
+#3628=EDGE_LOOP($,(#3624,#3625,#3626,#3627));
+#3629=FACE_OUTER_BOUND('',#3628,.T.);
+#3630=ADVANCED_FACE('',(#3629),#3623,.F.);
+#3631=CARTESIAN_POINT($,(402.053586493049,305.501340352839,0));
+#3632=DIRECTION($,(0,0,1));
+#3633=DIRECTION($,(1,0,0));
+#3634=AXIS2_PLACEMENT_3D($,#3631,#3632,#3633);
+#3635=CYLINDRICAL_SURFACE($,#3634,2.38125);
+#3636=ORIENTED_EDGE($,$,$,#888,.T.);
+#3637=CARTESIAN_POINT($,(404.434836493049,305.501340352839,0));
+#3638=DIRECTION($,(0,0,1));
+#3639=VECTOR($,#3638,1);
+#3640=LINE($,#3637,#3639);
+#3641=EDGE_CURVE($,#871,#1853,#3640,.T.);
+#3642=ORIENTED_EDGE($,$,$,#3641,.T.);
+#3643=ORIENTED_EDGE($,$,$,#1870,.F.);
+#3644=CARTESIAN_POINT($,(399.672336493049,305.501340352839,0));
+#3645=DIRECTION($,(0,0,1));
+#3646=VECTOR($,#3645,1);
+#3647=LINE($,#3644,#3646);
+#3648=EDGE_CURVE($,#873,#1855,#3647,.T.);
+#3649=ORIENTED_EDGE($,$,$,#3648,.F.);
+#3650=EDGE_LOOP($,(#3636,#3642,#3643,#3649));
+#3651=FACE_OUTER_BOUND('',#3650,.T.);
+#3652=ADVANCED_FACE('',(#3651),#3635,.F.);
+#3653=CARTESIAN_POINT($,(402.053586493049,305.501340352839,0));
+#3654=DIRECTION($,(0,0,1));
+#3655=DIRECTION($,(1,0,0));
+#3656=AXIS2_PLACEMENT_3D($,#3653,#3654,#3655);
+#3657=CYLINDRICAL_SURFACE($,#3656,2.38125);
+#3658=ORIENTED_EDGE($,$,$,#880,.T.);
+#3659=ORIENTED_EDGE($,$,$,#3648,.T.);
+#3660=ORIENTED_EDGE($,$,$,#1862,.F.);
+#3661=ORIENTED_EDGE($,$,$,#3641,.F.);
+#3662=EDGE_LOOP($,(#3658,#3659,#3660,#3661));
+#3663=FACE_OUTER_BOUND('',#3662,.T.);
+#3664=ADVANCED_FACE('',(#3663),#3657,.F.);
+#3665=CARTESIAN_POINT($,(402.053586493049,343.601340352839,0));
+#3666=DIRECTION($,(0,0,1));
+#3667=DIRECTION($,(1,0,0));
+#3668=AXIS2_PLACEMENT_3D($,#3665,#3666,#3667);
+#3669=CYLINDRICAL_SURFACE($,#3668,2.38125);
+#3670=ORIENTED_EDGE($,$,$,#910,.T.);
+#3671=CARTESIAN_POINT($,(404.434836493049,343.601340352839,0));
+#3672=DIRECTION($,(0,0,1));
+#3673=VECTOR($,#3672,1);
+#3674=LINE($,#3671,#3673);
+#3675=EDGE_CURVE($,#893,#1875,#3674,.T.);
+#3676=ORIENTED_EDGE($,$,$,#3675,.T.);
+#3677=ORIENTED_EDGE($,$,$,#1892,.F.);
+#3678=CARTESIAN_POINT($,(399.672336493049,343.601340352839,0));
+#3679=DIRECTION($,(0,0,1));
+#3680=VECTOR($,#3679,1);
+#3681=LINE($,#3678,#3680);
+#3682=EDGE_CURVE($,#895,#1877,#3681,.T.);
+#3683=ORIENTED_EDGE($,$,$,#3682,.F.);
+#3684=EDGE_LOOP($,(#3670,#3676,#3677,#3683));
+#3685=FACE_OUTER_BOUND('',#3684,.T.);
+#3686=ADVANCED_FACE('',(#3685),#3669,.F.);
+#3687=CARTESIAN_POINT($,(402.053586493049,343.601340352839,0));
+#3688=DIRECTION($,(0,0,1));
+#3689=DIRECTION($,(1,0,0));
+#3690=AXIS2_PLACEMENT_3D($,#3687,#3688,#3689);
+#3691=CYLINDRICAL_SURFACE($,#3690,2.38125);
+#3692=ORIENTED_EDGE($,$,$,#902,.T.);
+#3693=ORIENTED_EDGE($,$,$,#3682,.T.);
+#3694=ORIENTED_EDGE($,$,$,#1884,.F.);
+#3695=ORIENTED_EDGE($,$,$,#3675,.F.);
+#3696=EDGE_LOOP($,(#3692,#3693,#3694,#3695));
+#3697=FACE_OUTER_BOUND('',#3696,.T.);
+#3698=ADVANCED_FACE('',(#3697),#3691,.F.);
+#3699=CARTESIAN_POINT($,(126.72834017642,201.998880352839,0));
+#3700=DIRECTION($,(-1,0,0));
+#3701=DIRECTION($,(0,0,1));
+#3702=AXIS2_PLACEMENT_3D($,#3699,#3700,#3701);
+#3703=PLANE($,#3702);
+#3704=ORIENTED_EDGE($,$,$,#944,.T.);
+#3705=CARTESIAN_POINT($,(126.72834017642,290.898880352839,-0));
+#3706=DIRECTION($,(0,0,1));
+#3707=VECTOR($,#3706,1);
+#3708=LINE($,#3705,#3707);
+#3709=EDGE_CURVE($,#933,#1915,#3708,.T.);
+#3710=ORIENTED_EDGE($,$,$,#3709,.T.);
+#3711=ORIENTED_EDGE($,$,$,#1926,.F.);
+#3712=CARTESIAN_POINT($,(126.72834017642,201.998880352839,0));
+#3713=DIRECTION($,(0,0,1));
+#3714=VECTOR($,#3713,1);
+#3715=LINE($,#3712,#3714);
+#3716=EDGE_CURVE($,#917,#1899,#3715,.T.);
+#3717=ORIENTED_EDGE($,$,$,#3716,.F.);
+#3718=EDGE_LOOP($,(#3704,#3710,#3711,#3717));
+#3719=FACE_OUTER_BOUND('',#3718,.T.);
+#3720=ADVANCED_FACE('',(#3719),#3703,.T.);
+#3721=CARTESIAN_POINT($,(126.72834017642,290.898880352839,0));
+#3722=DIRECTION($,(0,-1,0));
+#3723=DIRECTION($,(0,0,1));
+#3724=AXIS2_PLACEMENT_3D($,#3721,#3722,#3723);
+#3725=PLANE($,#3724);
+#3726=ORIENTED_EDGE($,$,$,#938,.T.);
+#3727=CARTESIAN_POINT($,(107.67834017642,290.898880352839,-0));
+#3728=DIRECTION($,(0,0,1));
+#3729=VECTOR($,#3728,1);
+#3730=LINE($,#3727,#3729);
+#3731=EDGE_CURVE($,#925,#1907,#3730,.T.);
+#3732=ORIENTED_EDGE($,$,$,#3731,.T.);
+#3733=ORIENTED_EDGE($,$,$,#1920,.F.);
+#3734=ORIENTED_EDGE($,$,$,#3709,.F.);
+#3735=EDGE_LOOP($,(#3726,#3732,#3733,#3734));
+#3736=FACE_OUTER_BOUND('',#3735,.T.);
+#3737=ADVANCED_FACE('',(#3736),#3725,.T.);
+#3738=CARTESIAN_POINT($,(107.67834017642,290.898880352839,0));
+#3739=DIRECTION($,(1,0,0));
+#3740=DIRECTION($,(0,0,1));
+#3741=AXIS2_PLACEMENT_3D($,#3738,#3739,#3740);
+#3742=PLANE($,#3741);
+#3743=ORIENTED_EDGE($,$,$,#930,.T.);
+#3744=CARTESIAN_POINT($,(107.67834017642,201.998880352839,-0));
+#3745=DIRECTION($,(0,0,1));
+#3746=VECTOR($,#3745,1);
+#3747=LINE($,#3744,#3746);
+#3748=EDGE_CURVE($,#915,#1897,#3747,.T.);
+#3749=ORIENTED_EDGE($,$,$,#3748,.T.);
+#3750=ORIENTED_EDGE($,$,$,#1912,.F.);
+#3751=ORIENTED_EDGE($,$,$,#3731,.F.);
+#3752=EDGE_LOOP($,(#3743,#3749,#3750,#3751));
+#3753=FACE_OUTER_BOUND('',#3752,.T.);
+#3754=ADVANCED_FACE('',(#3753),#3742,.T.);
+#3755=CARTESIAN_POINT($,(107.67834017642,201.998880352839,0));
+#3756=DIRECTION($,(0,1,0));
+#3757=DIRECTION($,(0,0,1));
+#3758=AXIS2_PLACEMENT_3D($,#3755,#3756,#3757);
+#3759=PLANE($,#3758);
+#3760=ORIENTED_EDGE($,$,$,#922,.T.);
+#3761=ORIENTED_EDGE($,$,$,#3716,.T.);
+#3762=ORIENTED_EDGE($,$,$,#1904,.F.);
+#3763=ORIENTED_EDGE($,$,$,#3748,.F.);
+#3764=EDGE_LOOP($,(#3760,#3761,#3762,#3763));
+#3765=FACE_OUTER_BOUND('',#3764,.T.);
+#3766=ADVANCED_FACE('',(#3765),#3759,.T.);
+#3767=CARTESIAN_POINT($,(190.22834017642,201.998880352839,0));
+#3768=DIRECTION($,(-1,0,0));
+#3769=DIRECTION($,(0,0,1));
+#3770=AXIS2_PLACEMENT_3D($,#3767,#3768,#3769);
+#3771=PLANE($,#3770);
+#3772=ORIENTED_EDGE($,$,$,#978,.T.);
+#3773=CARTESIAN_POINT($,(190.22834017642,290.898880352839,-0));
+#3774=DIRECTION($,(0,0,1));
+#3775=VECTOR($,#3774,1);
+#3776=LINE($,#3773,#3775);
+#3777=EDGE_CURVE($,#967,#1949,#3776,.T.);
+#3778=ORIENTED_EDGE($,$,$,#3777,.T.);
+#3779=ORIENTED_EDGE($,$,$,#1960,.F.);
+#3780=CARTESIAN_POINT($,(190.22834017642,201.998880352839,0));
+#3781=DIRECTION($,(0,0,1));
+#3782=VECTOR($,#3781,1);
+#3783=LINE($,#3780,#3782);
+#3784=EDGE_CURVE($,#951,#1933,#3783,.T.);
+#3785=ORIENTED_EDGE($,$,$,#3784,.F.);
+#3786=EDGE_LOOP($,(#3772,#3778,#3779,#3785));
+#3787=FACE_OUTER_BOUND('',#3786,.T.);
+#3788=ADVANCED_FACE('',(#3787),#3771,.T.);
+#3789=CARTESIAN_POINT($,(190.22834017642,290.898880352839,0));
+#3790=DIRECTION($,(0,-1,0));
+#3791=DIRECTION($,(0,0,1));
+#3792=AXIS2_PLACEMENT_3D($,#3789,#3790,#3791);
+#3793=PLANE($,#3792);
+#3794=ORIENTED_EDGE($,$,$,#972,.T.);
+#3795=CARTESIAN_POINT($,(171.17834017642,290.898880352839,-0));
+#3796=DIRECTION($,(0,0,1));
+#3797=VECTOR($,#3796,1);
+#3798=LINE($,#3795,#3797);
+#3799=EDGE_CURVE($,#959,#1941,#3798,.T.);
+#3800=ORIENTED_EDGE($,$,$,#3799,.T.);
+#3801=ORIENTED_EDGE($,$,$,#1954,.F.);
+#3802=ORIENTED_EDGE($,$,$,#3777,.F.);
+#3803=EDGE_LOOP($,(#3794,#3800,#3801,#3802));
+#3804=FACE_OUTER_BOUND('',#3803,.T.);
+#3805=ADVANCED_FACE('',(#3804),#3793,.T.);
+#3806=CARTESIAN_POINT($,(171.17834017642,290.898880352839,0));
+#3807=DIRECTION($,(1,0,0));
+#3808=DIRECTION($,(0,0,1));
+#3809=AXIS2_PLACEMENT_3D($,#3806,#3807,#3808);
+#3810=PLANE($,#3809);
+#3811=ORIENTED_EDGE($,$,$,#964,.T.);
+#3812=CARTESIAN_POINT($,(171.17834017642,201.998880352839,-0));
+#3813=DIRECTION($,(0,0,1));
+#3814=VECTOR($,#3813,1);
+#3815=LINE($,#3812,#3814);
+#3816=EDGE_CURVE($,#949,#1931,#3815,.T.);
+#3817=ORIENTED_EDGE($,$,$,#3816,.T.);
+#3818=ORIENTED_EDGE($,$,$,#1946,.F.);
+#3819=ORIENTED_EDGE($,$,$,#3799,.F.);
+#3820=EDGE_LOOP($,(#3811,#3817,#3818,#3819));
+#3821=FACE_OUTER_BOUND('',#3820,.T.);
+#3822=ADVANCED_FACE('',(#3821),#3810,.T.);
+#3823=CARTESIAN_POINT($,(171.17834017642,201.998880352839,0));
+#3824=DIRECTION($,(0,1,0));
+#3825=DIRECTION($,(0,0,1));
+#3826=AXIS2_PLACEMENT_3D($,#3823,#3824,#3825);
+#3827=PLANE($,#3826);
+#3828=ORIENTED_EDGE($,$,$,#956,.T.);
+#3829=ORIENTED_EDGE($,$,$,#3784,.T.);
+#3830=ORIENTED_EDGE($,$,$,#1938,.F.);
+#3831=ORIENTED_EDGE($,$,$,#3816,.F.);
+#3832=EDGE_LOOP($,(#3828,#3829,#3830,#3831));
+#3833=FACE_OUTER_BOUND('',#3832,.T.);
+#3834=ADVANCED_FACE('',(#3833),#3827,.T.);
+#3835=CLOSED_SHELL($,(#982,#1964,#1986,#2003,#2020,#2037,#2054,#2071,#2088,#2105,#2122,#2139,#2156,#2173,#2190,#2207,#2224,#2241,#2258,#2275,#2292,#2309,#2326,#2343,#2360,#2377,#2394,#2411,#2428,#2445,#2462,#2479,#2496,#2513,#2530,#2547,#2564,#2581,#2598,#2615,#2632,#2649,#2666,#2683,#2700,#2717,#2734,#2751,#2768,#2785,#2802,#2819,#2836,#2853,#2870,#2887,#2904,#2921,#2938,#2955,#2972,#2989,#3006,#3023,#3040,#3057,#3074,#3091,#3108,#3125,#3142,#3159,#3176,#3188,#3210,#3222,#3244,#3256,#3278,#3290,#3312,#3324,#3346,#3358,#3380,#3392,#3414,#3426,#3448,#3460,#3482,#3494,#3516,#3528,#3550,#3562,#3584,#3596,#3618,#3630,#3652,#3664,#3686,#3698,#3720,#3737,#3754,#3766,#3788,#3805,#3822,#3834));
+#3836=MANIFOLD_SOLID_BREP('sheetmetal-Ctc03 flat pattern',#3835);
+#3837=APPLICATION_CONTEXT('mechanical design');
+#3838=PRODUCT_CONTEXT('',#3837,'mechanical');
+#3839=PRODUCT('sheetmetal_Ctc03_flat','sheetmetal-Ctc03 flat pattern','',(#3838));
+#3840=PRODUCT_DEFINITION_FORMATION('','',#3839);
+#3841=PRODUCT_DEFINITION_CONTEXT('design',#3837,'design');
+#3842=PRODUCT_DEFINITION('','',#3840,#3841);
+#3843=PRODUCT_DEFINITION_SHAPE('','',#3842);
+#3844=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#3845=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#3846=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#3847=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#3844,#3845,#3846))REPRESENTATION_CONTEXT('3','3D'));
+#3848=SHAPE_REPRESENTATION('sheetmetal-Ctc03 flat pattern',(#3836),#3847);
+#3849=SHAPE_DEFINITION_REPRESENTATION(#3843,#3848);
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
index 68654870..b42ca35c 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.svg
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-flat.svg
@@ -1,24 +1,24 @@
<?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">
+<svg xmlns="http://www.w3.org/2000/svg" width="428.752mm" height="649.298mm" viewBox="0 0 428.752 649.298">
<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-FrontMountingFlange" d="M 76.176 637.298 L 133.326 637.298 L 133.326 611.898 L 139.676 605.548 L 253.976 605.548 L 260.326 611.898 L 260.326 637.298 L 300.966 637.298 L 300.966 593.818 L 76.176 593.818 L 76.176 637.298 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-RearMountingFlange" d="M 300.966 12 L 250.166 12 L 243.816 18.35 L 243.816 37.4 L 237.466 43.75 L 123.166 43.75 L 116.816 37.4 L 116.816 18.35 L 110.466 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"/>
+<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 250.166 12 L 243.816 18.35 L 243.816 37.4 L 237.466 43.75 L 123.166 43.75 L 116.816 37.4 L 116.816 18.35 L 110.466 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 637.298 L 133.326 637.298 L 133.326 611.898 L 139.676 605.548 L 253.976 605.548 L 260.326 611.898 L 260.326 637.298 L 300.966 637.298 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"/>
@@ -69,5 +69,5 @@
<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>
+<text x="4" y="6" font-family="sans-serif" font-size="3" fill="#334155">Valid · K=0.5 · SHA-256 e3ec913e24f6</text>
</svg>
diff --git a/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step b/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step
index 9545112e..0283d142 100644
--- a/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step
+++ b/docs/modules/sheetmetal/artifacts/m8/ctc03-formed.step
@@ -1024,7 +1024,7 @@ DATA;
#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));
+#1020=CARTESIAN_POINT($,(-8.255,0.002539999999996,1.90746000000001));
#1021=VERTEX_POINT($,#1020);
#1022=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
#1023=DIRECTION($,(0,-1,0));
@@ -1032,1771 +1032,2233 @@ DATA;
#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));
+#1028=CARTESIAN_POINT($,(-48.895,0.002539999999996,1.90746000000001));
#1029=VERTEX_POINT($,#1028);
-#1030=CARTESIAN_POINT($,(-8.255,12.70254,1.90746000000001));
+#1030=CARTESIAN_POINT($,(-8.255,0.002539999999996,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));
+#1036=CARTESIAN_POINT($,(-48.895,25.40254,1.90746000000001));
+#1037=VERTEX_POINT($,#1036);
+#1038=CARTESIAN_POINT($,(-48.895,0.002539999999996,1.90746000000001));
+#1039=DIRECTION($,(0,1,0));
+#1040=VECTOR($,#1039,1);
+#1041=LINE($,#1038,#1040);
+#1042=EDGE_CURVE($,#1029,#1037,#1041,.T.);
+#1043=ORIENTED_EDGE($,$,$,#1042,.T.);
+#1044=CARTESIAN_POINT($,(-55.245,31.75254,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));
+#1046=CARTESIAN_POINT($,(-48.895,25.40254,1.90746000000001));
+#1047=DIRECTION($,(-0.707106781186548,0.707106781186547,0));
+#1048=VECTOR($,#1047,1);
+#1049=LINE($,#1046,#1048);
+#1050=EDGE_CURVE($,#1037,#1045,#1049,.T.);
+#1051=ORIENTED_EDGE($,$,$,#1050,.T.);
+#1052=CARTESIAN_POINT($,(-169.545,31.75254,1.90746000000001));
+#1053=VERTEX_POINT($,#1052);
+#1054=CARTESIAN_POINT($,(-55.245,31.75254,1.90746000000001));
+#1055=DIRECTION($,(-1,0,0));
+#1056=VECTOR($,#1055,1);
+#1057=LINE($,#1054,#1056);
+#1058=EDGE_CURVE($,#1045,#1053,#1057,.T.);
+#1059=ORIENTED_EDGE($,$,$,#1058,.T.);
+#1060=CARTESIAN_POINT($,(-175.895,25.40254,1.90746000000001));
+#1061=VERTEX_POINT($,#1060);
+#1062=CARTESIAN_POINT($,(-169.545,31.75254,1.90746000000001));
+#1063=DIRECTION($,(-0.707106781186547,-0.707106781186548,0));
+#1064=VECTOR($,#1063,1);
+#1065=LINE($,#1062,#1064);
+#1066=EDGE_CURVE($,#1053,#1061,#1065,.T.);
+#1067=ORIENTED_EDGE($,$,$,#1066,.T.);
+#1068=CARTESIAN_POINT($,(-175.895,0.002539999999996,1.90746000000001));
+#1069=VERTEX_POINT($,#1068);
+#1070=CARTESIAN_POINT($,(-175.895,25.40254,1.90746000000001));
+#1071=DIRECTION($,(0,-1,0));
+#1072=VECTOR($,#1071,1);
+#1073=LINE($,#1070,#1072);
+#1074=EDGE_CURVE($,#1061,#1069,#1073,.T.);
+#1075=ORIENTED_EDGE($,$,$,#1074,.T.);
+#1076=CARTESIAN_POINT($,(-233.045,0.002539999999996,1.90746000000001));
+#1077=VERTEX_POINT($,#1076);
+#1078=CARTESIAN_POINT($,(-175.895,0.002539999999996,1.90746000000001));
+#1079=DIRECTION($,(-1,0,0));
+#1080=VECTOR($,#1079,1);
+#1081=LINE($,#1078,#1080);
+#1082=EDGE_CURVE($,#1069,#1077,#1081,.T.);
+#1083=ORIENTED_EDGE($,$,$,#1082,.T.);
+#1084=CARTESIAN_POINT($,(-233.045,0.002539999999996,1.90746000000001));
#1085=DIRECTION($,(0,1,0));
#1086=VECTOR($,#1085,1);
#1087=LINE($,#1084,#1086);
-#1088=EDGE_CURVE($,#1075,#1083,#1087,.T.);
+#1088=EDGE_CURVE($,#1077,#1011,#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.);
+#1090=EDGE_LOOP($,(#1019,#1027,#1035,#1043,#1051,#1059,#1067,#1075,#1083,#1089));
+#1091=FACE_OUTER_BOUND('',#1090,.T.);
+#1092=CARTESIAN_POINT($,(-216.6874,19.05,1.90746000000001));
+#1093=VERTEX_POINT($,#1092);
+#1094=CARTESIAN_POINT($,(-222.25,19.05,1.90746000000001));
+#1095=DIRECTION($,(0,0,1));
+#1096=DIRECTION($,(1,0,0));
+#1097=AXIS2_PLACEMENT_3D($,#1094,#1095,#1096);
+#1098=CIRCLE($,#1097,5.5626);
+#1099=EDGE_CURVE($,#1093,#1093,#1098,.T.);
+#1100=ORIENTED_EDGE($,$,$,#1099,.T.);
+#1101=EDGE_LOOP($,(#1100));
+#1102=FACE_BOUND('',#1101,.T.);
+#1103=CARTESIAN_POINT($,(-13.4874,19.05,1.90746000000001));
+#1104=VERTEX_POINT($,#1103);
+#1105=CARTESIAN_POINT($,(-19.05,19.05,1.90746000000001));
+#1106=DIRECTION($,(0,0,1));
+#1107=DIRECTION($,(1,0,0));
+#1108=AXIS2_PLACEMENT_3D($,#1105,#1106,#1107);
+#1109=CIRCLE($,#1108,5.5626);
+#1110=EDGE_CURVE($,#1104,#1104,#1109,.T.);
+#1111=ORIENTED_EDGE($,$,$,#1110,.T.);
+#1112=EDGE_LOOP($,(#1111));
+#1113=FACE_BOUND('',#1112,.T.);
+#1114=ADVANCED_FACE('',(#1091,#1102,#1113),#1009,.T.);
+#1115=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#1116=DIRECTION($,(-0,-0,-1));
+#1117=DIRECTION($,(1,0,0));
+#1118=AXIS2_PLACEMENT_3D($,#1115,#1116,#1117);
+#1119=PLANE($,#1118);
+#1120=CARTESIAN_POINT($,(-233.045,0.002539999999996,0.00246000000001));
+#1121=VERTEX_POINT($,#1120);
+#1122=CARTESIAN_POINT($,(-175.895,0.002539999999996,0.00246000000001));
+#1123=VERTEX_POINT($,#1122);
+#1124=CARTESIAN_POINT($,(-233.045,0.002539999999996,0.00246000000001));
+#1125=DIRECTION($,(1,0,0));
+#1126=VECTOR($,#1125,1);
+#1127=LINE($,#1124,#1126);
+#1128=EDGE_CURVE($,#1121,#1123,#1127,.T.);
+#1129=ORIENTED_EDGE($,$,$,#1128,.T.);
+#1130=CARTESIAN_POINT($,(-175.895,25.40254,0.00246000000001));
+#1131=VERTEX_POINT($,#1130);
+#1132=CARTESIAN_POINT($,(-175.895,0.002539999999996,0.00246000000001));
+#1133=DIRECTION($,(0,1,0));
+#1134=VECTOR($,#1133,1);
+#1135=LINE($,#1132,#1134);
+#1136=EDGE_CURVE($,#1123,#1131,#1135,.T.);
+#1137=ORIENTED_EDGE($,$,$,#1136,.T.);
+#1138=CARTESIAN_POINT($,(-169.545,31.75254,0.00246000000001));
+#1139=VERTEX_POINT($,#1138);
+#1140=CARTESIAN_POINT($,(-175.895,25.40254,0.00246000000001));
+#1141=DIRECTION($,(0.707106781186547,0.707106781186548,0));
+#1142=VECTOR($,#1141,1);
+#1143=LINE($,#1140,#1142);
+#1144=EDGE_CURVE($,#1131,#1139,#1143,.T.);
+#1145=ORIENTED_EDGE($,$,$,#1144,.T.);
+#1146=CARTESIAN_POINT($,(-55.245,31.75254,0.00246000000001));
+#1147=VERTEX_POINT($,#1146);
+#1148=CARTESIAN_POINT($,(-169.545,31.75254,0.00246000000001));
+#1149=DIRECTION($,(1,0,0));
+#1150=VECTOR($,#1149,1);
+#1151=LINE($,#1148,#1150);
+#1152=EDGE_CURVE($,#1139,#1147,#1151,.T.);
+#1153=ORIENTED_EDGE($,$,$,#1152,.T.);
+#1154=CARTESIAN_POINT($,(-48.895,25.40254,0.00246000000001));
+#1155=VERTEX_POINT($,#1154);
+#1156=CARTESIAN_POINT($,(-55.245,31.75254,0.00246000000001));
+#1157=DIRECTION($,(0.707106781186548,-0.707106781186547,0));
+#1158=VECTOR($,#1157,1);
+#1159=LINE($,#1156,#1158);
+#1160=EDGE_CURVE($,#1147,#1155,#1159,.T.);
+#1161=ORIENTED_EDGE($,$,$,#1160,.T.);
+#1162=CARTESIAN_POINT($,(-48.895,0.002539999999996,0.00246000000001));
+#1163=VERTEX_POINT($,#1162);
+#1164=CARTESIAN_POINT($,(-48.895,25.40254,0.00246000000001));
+#1165=DIRECTION($,(0,-1,0));
+#1166=VECTOR($,#1165,1);
+#1167=LINE($,#1164,#1166);
+#1168=EDGE_CURVE($,#1155,#1163,#1167,.T.);
+#1169=ORIENTED_EDGE($,$,$,#1168,.T.);
+#1170=CARTESIAN_POINT($,(-8.255,0.002539999999996,0.00246000000001));
+#1171=VERTEX_POINT($,#1170);
+#1172=CARTESIAN_POINT($,(-48.895,0.002539999999996,0.00246000000001));
+#1173=DIRECTION($,(1,0,0));
+#1174=VECTOR($,#1173,1);
+#1175=LINE($,#1172,#1174);
+#1176=EDGE_CURVE($,#1163,#1171,#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));
+#1178=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#1179=VERTEX_POINT($,#1178);
+#1180=CARTESIAN_POINT($,(-8.255,0.002539999999996,0.00246000000001));
+#1181=DIRECTION($,(0,1,0));
+#1182=VECTOR($,#1181,1);
+#1183=LINE($,#1180,#1182);
+#1184=EDGE_CURVE($,#1171,#1179,#1183,.T.);
+#1185=ORIENTED_EDGE($,$,$,#1184,.T.);
+#1186=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
#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.);
+#1188=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#1189=DIRECTION($,(-1,0,0));
+#1190=VECTOR($,#1189,1);
+#1191=LINE($,#1188,#1190);
+#1192=EDGE_CURVE($,#1179,#1187,#1191,.T.);
+#1193=ORIENTED_EDGE($,$,$,#1192,.T.);
+#1194=CARTESIAN_POINT($,(-233.045,43.48226,0.00246000000001));
+#1195=DIRECTION($,(0,-1,0));
+#1196=VECTOR($,#1195,1);
+#1197=LINE($,#1194,#1196);
+#1198=EDGE_CURVE($,#1187,#1121,#1197,.T.);
+#1199=ORIENTED_EDGE($,$,$,#1198,.T.);
+#1200=EDGE_LOOP($,(#1129,#1137,#1145,#1153,#1161,#1169,#1177,#1185,#1193,#1199));
+#1201=FACE_OUTER_BOUND('',#1200,.T.);
+#1202=CARTESIAN_POINT($,(-216.6874,19.05,0.00246000000001));
+#1203=VERTEX_POINT($,#1202);
+#1204=CARTESIAN_POINT($,(-222.25,19.05,0.00246000000001));
+#1205=DIRECTION($,(0,0,1));
+#1206=DIRECTION($,(1,0,0));
+#1207=AXIS2_PLACEMENT_3D($,#1204,#1205,#1206);
+#1208=CIRCLE($,#1207,5.5626);
+#1209=EDGE_CURVE($,#1203,#1203,#1208,.T.);
+#1210=ORIENTED_EDGE($,$,$,#1209,.T.);
+#1211=EDGE_LOOP($,(#1210));
+#1212=FACE_BOUND('',#1211,.T.);
+#1213=CARTESIAN_POINT($,(-13.4874,19.05,0.00246000000001));
+#1214=VERTEX_POINT($,#1213);
+#1215=CARTESIAN_POINT($,(-19.05,19.05,0.00246000000001));
+#1216=DIRECTION($,(0,0,1));
+#1217=DIRECTION($,(1,0,0));
+#1218=AXIS2_PLACEMENT_3D($,#1215,#1216,#1217);
+#1219=CIRCLE($,#1218,5.5626);
+#1220=EDGE_CURVE($,#1214,#1214,#1219,.T.);
+#1221=ORIENTED_EDGE($,$,$,#1220,.T.);
+#1222=EDGE_LOOP($,(#1221));
+#1223=FACE_BOUND('',#1222,.T.);
+#1224=ADVANCED_FACE('',(#1201,#1212,#1223),#1119,.F.);
+#1225=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1226=DIRECTION($,(1,0,0));
+#1227=DIRECTION($,(0,1,0));
+#1228=AXIS2_PLACEMENT_3D($,#1225,#1226,#1227);
+#1229=CYLINDRICAL_SURFACE($,#1228,6.35);
+#1230=ORIENTED_EDGE($,$,$,#506,.F.);
+#1231=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#1232=DIRECTION($,(-1,-0,-0));
+#1233=DIRECTION($,(0,1,0));
+#1234=AXIS2_PLACEMENT_3D($,#1231,#1232,#1233);
+#1235=CIRCLE($,#1234,6.35);
+#1236=TRIMMED_CURVE($,#1235,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1237=EDGE_CURVE($,#493,#1013,#1236,.T.);
+#1238=ORIENTED_EDGE($,$,$,#1237,.T.);
+#1239=ORIENTED_EDGE($,$,$,#1018,.F.);
+#1240=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1241=DIRECTION($,(1,0,0));
+#1242=DIRECTION($,(0,0.000000000000001,-1));
+#1243=AXIS2_PLACEMENT_3D($,#1240,#1241,#1242);
+#1244=CIRCLE($,#1243,6.35);
+#1245=TRIMMED_CURVE($,#1244,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1246=EDGE_CURVE($,#1011,#501,#1245,.T.);
+#1247=ORIENTED_EDGE($,$,$,#1246,.T.);
+#1248=EDGE_LOOP($,(#1230,#1238,#1239,#1247));
+#1249=FACE_OUTER_BOUND('',#1248,.T.);
+#1250=ADVANCED_FACE('',(#1249),#1229,.T.);
+#1251=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1252=DIRECTION($,(1,0,0));
+#1253=DIRECTION($,(0,1,0));
+#1254=AXIS2_PLACEMENT_3D($,#1251,#1252,#1253);
+#1255=CYLINDRICAL_SURFACE($,#1254,8.255);
+#1256=ORIENTED_EDGE($,$,$,#1192,.F.);
+#1257=CARTESIAN_POINT($,(-8.255,43.48226,8.25746000000001));
+#1258=DIRECTION($,(1,0,0));
+#1259=DIRECTION($,(0,0.000000000000001,-1));
+#1260=AXIS2_PLACEMENT_3D($,#1257,#1258,#1259);
+#1261=CIRCLE($,#1260,8.255);
+#1262=TRIMMED_CURVE($,#1261,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1263=EDGE_CURVE($,#1179,#525,#1262,.T.);
+#1264=ORIENTED_EDGE($,$,$,#1263,.T.);
+#1265=ORIENTED_EDGE($,$,$,#530,.F.);
+#1266=CARTESIAN_POINT($,(-233.045,43.48226,8.25746000000001));
+#1267=DIRECTION($,(-1,-0,-0));
+#1268=DIRECTION($,(0,1,0));
+#1269=AXIS2_PLACEMENT_3D($,#1266,#1267,#1268);
+#1270=CIRCLE($,#1269,8.255);
+#1271=TRIMMED_CURVE($,#1270,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1272=EDGE_CURVE($,#523,#1187,#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));
+#1274=EDGE_LOOP($,(#1256,#1264,#1265,#1273));
+#1275=FACE_OUTER_BOUND('',#1274,.T.);
+#1276=ADVANCED_FACE('',(#1275),#1255,.F.);
+#1277=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1278=DIRECTION($,(0,0,1));
+#1279=DIRECTION($,(-1,0,0));
+#1280=AXIS2_PLACEMENT_3D($,#1277,#1278,#1279);
+#1281=PLANE($,#1280);
+#1282=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
#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));
+#1284=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1285=VERTEX_POINT($,#1284);
+#1286=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#1287=DIRECTION($,(-1,0,0));
+#1288=VECTOR($,#1287,1);
+#1289=LINE($,#1286,#1288);
+#1290=EDGE_CURVE($,#1283,#1285,#1289,.T.);
+#1291=ORIENTED_EDGE($,$,$,#1290,.T.);
+#1292=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1293=VERTEX_POINT($,#1292);
+#1294=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#1295=DIRECTION($,(0,1,0));
+#1296=VECTOR($,#1295,1);
+#1297=LINE($,#1294,#1296);
+#1298=EDGE_CURVE($,#1285,#1293,#1297,.T.);
+#1299=ORIENTED_EDGE($,$,$,#1298,.T.);
+#1300=CARTESIAN_POINT($,(-198.755,485.44226,1.90746000000001));
+#1301=VERTEX_POINT($,#1300);
+#1302=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#1303=DIRECTION($,(1,0,0));
+#1304=VECTOR($,#1303,1);
+#1305=LINE($,#1302,#1304);
+#1306=EDGE_CURVE($,#1293,#1301,#1305,.T.);
+#1307=ORIENTED_EDGE($,$,$,#1306,.T.);
+#1308=CARTESIAN_POINT($,(-192.405,479.09226,1.90746000000001));
+#1309=VERTEX_POINT($,#1308);
+#1310=CARTESIAN_POINT($,(-198.755,485.44226,1.90746000000001));
+#1311=DIRECTION($,(0.707106781186546,-0.707106781186549,0));
+#1312=VECTOR($,#1311,1);
+#1313=LINE($,#1310,#1312);
+#1314=EDGE_CURVE($,#1301,#1309,#1313,.T.);
+#1315=ORIENTED_EDGE($,$,$,#1314,.T.);
+#1316=CARTESIAN_POINT($,(-192.405,460.04226,1.90746000000001));
+#1317=VERTEX_POINT($,#1316);
+#1318=CARTESIAN_POINT($,(-192.405,479.09226,1.90746000000001));
+#1319=DIRECTION($,(0,-1,0));
+#1320=VECTOR($,#1319,1);
+#1321=LINE($,#1318,#1320);
+#1322=EDGE_CURVE($,#1309,#1317,#1321,.T.);
+#1323=ORIENTED_EDGE($,$,$,#1322,.T.);
+#1324=CARTESIAN_POINT($,(-186.055,453.69226,1.90746000000001));
+#1325=VERTEX_POINT($,#1324);
+#1326=CARTESIAN_POINT($,(-192.405,460.04226,1.90746000000001));
+#1327=DIRECTION($,(0.707106781186546,-0.707106781186549,0));
+#1328=VECTOR($,#1327,1);
+#1329=LINE($,#1326,#1328);
+#1330=EDGE_CURVE($,#1317,#1325,#1329,.T.);
+#1331=ORIENTED_EDGE($,$,$,#1330,.T.);
+#1332=CARTESIAN_POINT($,(-71.755,453.69226,1.90746000000001));
+#1333=VERTEX_POINT($,#1332);
+#1334=CARTESIAN_POINT($,(-186.055,453.69226,1.90746000000001));
+#1335=DIRECTION($,(1,0,0));
+#1336=VECTOR($,#1335,1);
+#1337=LINE($,#1334,#1336);
+#1338=EDGE_CURVE($,#1325,#1333,#1337,.T.);
+#1339=ORIENTED_EDGE($,$,$,#1338,.T.);
+#1340=CARTESIAN_POINT($,(-65.405,460.04226,1.90746000000001));
+#1341=VERTEX_POINT($,#1340);
+#1342=CARTESIAN_POINT($,(-71.755,453.69226,1.90746000000001));
+#1343=DIRECTION($,(0.707106781186546,0.707106781186549,0));
+#1344=VECTOR($,#1343,1);
+#1345=LINE($,#1342,#1344);
+#1346=EDGE_CURVE($,#1333,#1341,#1345,.T.);
+#1347=ORIENTED_EDGE($,$,$,#1346,.T.);
+#1348=CARTESIAN_POINT($,(-65.405,479.09226,1.90746000000001));
+#1349=VERTEX_POINT($,#1348);
+#1350=CARTESIAN_POINT($,(-65.405,460.04226,1.90746000000001));
+#1351=DIRECTION($,(0,1,0));
+#1352=VECTOR($,#1351,1);
+#1353=LINE($,#1350,#1352);
+#1354=EDGE_CURVE($,#1341,#1349,#1353,.T.);
+#1355=ORIENTED_EDGE($,$,$,#1354,.T.);
+#1356=CARTESIAN_POINT($,(-59.055,485.44226,1.90746000000001));
+#1357=VERTEX_POINT($,#1356);
+#1358=CARTESIAN_POINT($,(-65.405,479.09226,1.90746000000001));
+#1359=DIRECTION($,(0.707106781186546,0.707106781186549,0));
+#1360=VECTOR($,#1359,1);
+#1361=LINE($,#1358,#1360);
+#1362=EDGE_CURVE($,#1349,#1357,#1361,.T.);
+#1363=ORIENTED_EDGE($,$,$,#1362,.T.);
+#1364=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
#1365=VERTEX_POINT($,#1364);
-#1366=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
-#1367=DIRECTION($,(0,1,0));
+#1366=CARTESIAN_POINT($,(-59.055,485.44226,1.90746000000001));
+#1367=DIRECTION($,(1,0,0));
#1368=VECTOR($,#1367,1);
#1369=LINE($,#1366,#1368);
-#1370=EDGE_CURVE($,#1363,#1365,#1369,.T.);
+#1370=EDGE_CURVE($,#1357,#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));
+#1372=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#1373=DIRECTION($,(-0,-1,0));
+#1374=VECTOR($,#1373,1);
+#1375=LINE($,#1372,#1374);
+#1376=EDGE_CURVE($,#1365,#1283,#1375,.T.);
+#1377=ORIENTED_EDGE($,$,$,#1376,.T.);
+#1378=EDGE_LOOP($,(#1291,#1299,#1307,#1315,#1323,#1331,#1339,#1347,#1355,#1363,#1371,#1377));
+#1379=FACE_OUTER_BOUND('',#1378,.T.);
+#1380=CARTESIAN_POINT($,(-24.6126,466.3948,1.90746000000001));
#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));
+#1382=CARTESIAN_POINT($,(-19.05,466.3948,1.90746000000001));
+#1383=DIRECTION($,(0,0,1));
+#1384=DIRECTION($,(-1,0,0));
+#1385=AXIS2_PLACEMENT_3D($,#1382,#1383,#1384);
+#1386=CIRCLE($,#1385,5.5626);
+#1387=EDGE_CURVE($,#1381,#1381,#1386,.T.);
+#1388=ORIENTED_EDGE($,$,$,#1387,.T.);
+#1389=EDGE_LOOP($,(#1388));
+#1390=FACE_BOUND('',#1389,.T.);
+#1391=CARTESIAN_POINT($,(-227.8126,466.3948,1.90746000000001));
+#1392=VERTEX_POINT($,#1391);
+#1393=CARTESIAN_POINT($,(-222.25,466.3948,1.90746000000001));
+#1394=DIRECTION($,(0,0,1));
+#1395=DIRECTION($,(-1,0,0));
+#1396=AXIS2_PLACEMENT_3D($,#1393,#1394,#1395);
+#1397=CIRCLE($,#1396,5.5626);
+#1398=EDGE_CURVE($,#1392,#1392,#1397,.T.);
+#1399=ORIENTED_EDGE($,$,$,#1398,.T.);
+#1400=EDGE_LOOP($,(#1399));
+#1401=FACE_BOUND('',#1400,.T.);
+#1402=ADVANCED_FACE('',(#1379,#1390,#1401),#1281,.T.);
+#1403=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1404=DIRECTION($,(-0,-0,-1));
+#1405=DIRECTION($,(-1,0,0));
+#1406=AXIS2_PLACEMENT_3D($,#1403,#1404,#1405);
+#1407=PLANE($,#1406);
+#1408=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1409=VERTEX_POINT($,#1408);
+#1410=CARTESIAN_POINT($,(-59.055,485.44226,0.00246000000001));
+#1411=VERTEX_POINT($,#1410);
+#1412=CARTESIAN_POINT($,(-8.255,485.44226,0.00246000000001));
+#1413=DIRECTION($,(-1,0,0));
+#1414=VECTOR($,#1413,1);
+#1415=LINE($,#1412,#1414);
+#1416=EDGE_CURVE($,#1409,#1411,#1415,.T.);
+#1417=ORIENTED_EDGE($,$,$,#1416,.T.);
+#1418=CARTESIAN_POINT($,(-65.405,479.09226,0.00246000000001));
+#1419=VERTEX_POINT($,#1418);
+#1420=CARTESIAN_POINT($,(-59.055,485.44226,0.00246000000001));
+#1421=DIRECTION($,(-0.707106781186546,-0.707106781186549,0));
#1422=VECTOR($,#1421,1);
#1423=LINE($,#1420,#1422);
-#1424=EDGE_CURVE($,#1413,#1363,#1423,.T.);
+#1424=EDGE_CURVE($,#1411,#1419,#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));
+#1426=CARTESIAN_POINT($,(-65.405,460.04226,0.00246000000001));
+#1427=VERTEX_POINT($,#1426);
+#1428=CARTESIAN_POINT($,(-65.405,479.09226,0.00246000000001));
+#1429=DIRECTION($,(0,-1,0));
+#1430=VECTOR($,#1429,1);
+#1431=LINE($,#1428,#1430);
+#1432=EDGE_CURVE($,#1419,#1427,#1431,.T.);
+#1433=ORIENTED_EDGE($,$,$,#1432,.T.);
+#1434=CARTESIAN_POINT($,(-71.755,453.69226,0.00246000000001));
+#1435=VERTEX_POINT($,#1434);
+#1436=CARTESIAN_POINT($,(-65.405,460.04226,0.00246000000001));
+#1437=DIRECTION($,(-0.707106781186546,-0.707106781186549,0));
+#1438=VECTOR($,#1437,1);
+#1439=LINE($,#1436,#1438);
+#1440=EDGE_CURVE($,#1427,#1435,#1439,.T.);
+#1441=ORIENTED_EDGE($,$,$,#1440,.T.);
+#1442=CARTESIAN_POINT($,(-186.055,453.69226,0.00246000000001));
+#1443=VERTEX_POINT($,#1442);
+#1444=CARTESIAN_POINT($,(-71.755,453.69226,0.00246000000001));
+#1445=DIRECTION($,(-1,0,0));
+#1446=VECTOR($,#1445,1);
+#1447=LINE($,#1444,#1446);
+#1448=EDGE_CURVE($,#1435,#1443,#1447,.T.);
+#1449=ORIENTED_EDGE($,$,$,#1448,.T.);
+#1450=CARTESIAN_POINT($,(-192.405,460.04226,0.00246000000001));
#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.);
+#1452=CARTESIAN_POINT($,(-186.055,453.69226,0.00246000000001));
+#1453=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#1454=VECTOR($,#1453,1);
+#1455=LINE($,#1452,#1454);
+#1456=EDGE_CURVE($,#1443,#1451,#1455,.T.);
+#1457=ORIENTED_EDGE($,$,$,#1456,.T.);
+#1458=CARTESIAN_POINT($,(-192.405,479.09226,0.00246000000001));
+#1459=VERTEX_POINT($,#1458);
+#1460=CARTESIAN_POINT($,(-192.405,460.04226,0.00246000000001));
+#1461=DIRECTION($,(0,1,0));
+#1462=VECTOR($,#1461,1);
+#1463=LINE($,#1460,#1462);
+#1464=EDGE_CURVE($,#1451,#1459,#1463,.T.);
+#1465=ORIENTED_EDGE($,$,$,#1464,.T.);
+#1466=CARTESIAN_POINT($,(-198.755,485.44226,0.00246000000001));
+#1467=VERTEX_POINT($,#1466);
+#1468=CARTESIAN_POINT($,(-192.405,479.09226,0.00246000000001));
+#1469=DIRECTION($,(-0.707106781186546,0.707106781186549,0));
+#1470=VECTOR($,#1469,1);
+#1471=LINE($,#1468,#1470);
+#1472=EDGE_CURVE($,#1459,#1467,#1471,.T.);
+#1473=ORIENTED_EDGE($,$,$,#1472,.T.);
+#1474=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1475=VERTEX_POINT($,#1474);
+#1476=CARTESIAN_POINT($,(-198.755,485.44226,0.00246000000001));
+#1477=DIRECTION($,(-1,0,0));
+#1478=VECTOR($,#1477,1);
+#1479=LINE($,#1476,#1478);
+#1480=EDGE_CURVE($,#1467,#1475,#1479,.T.);
+#1481=ORIENTED_EDGE($,$,$,#1480,.T.);
+#1482=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1483=VERTEX_POINT($,#1482);
+#1484=CARTESIAN_POINT($,(-233.045,485.44226,0.00246000000001));
+#1485=DIRECTION($,(0,-1,0));
+#1486=VECTOR($,#1485,1);
+#1487=LINE($,#1484,#1486);
+#1488=EDGE_CURVE($,#1475,#1483,#1487,.T.);
+#1489=ORIENTED_EDGE($,$,$,#1488,.T.);
+#1490=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1491=VERTEX_POINT($,#1490);
+#1492=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#1493=DIRECTION($,(1,0,0));
+#1494=VECTOR($,#1493,1);
+#1495=LINE($,#1492,#1494);
+#1496=EDGE_CURVE($,#1483,#1491,#1495,.T.);
+#1497=ORIENTED_EDGE($,$,$,#1496,.T.);
+#1498=CARTESIAN_POINT($,(-8.255,440.99226,0.00246000000001));
+#1499=DIRECTION($,(0,1,0));
+#1500=VECTOR($,#1499,1);
+#1501=LINE($,#1498,#1500);
+#1502=EDGE_CURVE($,#1491,#1409,#1501,.T.);
+#1503=ORIENTED_EDGE($,$,$,#1502,.T.);
+#1504=EDGE_LOOP($,(#1417,#1425,#1433,#1441,#1449,#1457,#1465,#1473,#1481,#1489,#1497,#1503));
+#1505=FACE_OUTER_BOUND('',#1504,.T.);
+#1506=CARTESIAN_POINT($,(-24.6126,466.3948,0.00246000000001));
+#1507=VERTEX_POINT($,#1506);
+#1508=CARTESIAN_POINT($,(-19.05,466.3948,0.00246000000001));
+#1509=DIRECTION($,(0,0,1));
+#1510=DIRECTION($,(-1,0,0));
+#1511=AXIS2_PLACEMENT_3D($,#1508,#1509,#1510);
+#1512=CIRCLE($,#1511,5.5626);
+#1513=EDGE_CURVE($,#1507,#1507,#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));
+#1515=EDGE_LOOP($,(#1514));
+#1516=FACE_BOUND('',#1515,.T.);
+#1517=CARTESIAN_POINT($,(-227.8126,466.3948,0.00246000000001));
+#1518=VERTEX_POINT($,#1517);
+#1519=CARTESIAN_POINT($,(-222.25,466.3948,0.00246000000001));
+#1520=DIRECTION($,(0,0,1));
+#1521=DIRECTION($,(-1,0,0));
+#1522=AXIS2_PLACEMENT_3D($,#1519,#1520,#1521);
+#1523=CIRCLE($,#1522,5.5626);
+#1524=EDGE_CURVE($,#1518,#1518,#1523,.T.);
+#1525=ORIENTED_EDGE($,$,$,#1524,.T.);
+#1526=EDGE_LOOP($,(#1525));
+#1527=FACE_BOUND('',#1526,.T.);
+#1528=ADVANCED_FACE('',(#1505,#1516,#1527),#1407,.F.);
+#1529=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1530=DIRECTION($,(-1,0,0));
+#1531=DIRECTION($,(0,-1,0));
+#1532=AXIS2_PLACEMENT_3D($,#1529,#1530,#1531);
+#1533=CYLINDRICAL_SURFACE($,#1532,6.35000000000002);
+#1534=ORIENTED_EDGE($,$,$,#638,.F.);
+#1535=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1536=DIRECTION($,(1,-0,-0));
+#1537=DIRECTION($,(0,-1,0));
+#1538=AXIS2_PLACEMENT_3D($,#1535,#1536,#1537);
+#1539=CIRCLE($,#1538,6.35000000000002);
+#1540=TRIMMED_CURVE($,#1539,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1541=EDGE_CURVE($,#625,#1285,#1540,.T.);
+#1542=ORIENTED_EDGE($,$,$,#1541,.T.);
+#1543=ORIENTED_EDGE($,$,$,#1290,.F.);
+#1544=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1545=DIRECTION($,(-1,0,0));
+#1546=DIRECTION($,(0,0,-1));
+#1547=AXIS2_PLACEMENT_3D($,#1544,#1545,#1546);
+#1548=CIRCLE($,#1547,6.35);
+#1549=TRIMMED_CURVE($,#1548,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1550=EDGE_CURVE($,#1283,#633,#1549,.T.);
+#1551=ORIENTED_EDGE($,$,$,#1550,.T.);
+#1552=EDGE_LOOP($,(#1534,#1542,#1543,#1551));
+#1553=FACE_OUTER_BOUND('',#1552,.T.);
+#1554=ADVANCED_FACE('',(#1553),#1533,.T.);
+#1555=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1556=DIRECTION($,(-1,0,0));
+#1557=DIRECTION($,(0,-1,0));
+#1558=AXIS2_PLACEMENT_3D($,#1555,#1556,#1557);
+#1559=CYLINDRICAL_SURFACE($,#1558,8.255);
+#1560=ORIENTED_EDGE($,$,$,#1496,.F.);
+#1561=CARTESIAN_POINT($,(-233.045,440.99226,8.25746000000001));
+#1562=DIRECTION($,(-1,0,0));
+#1563=DIRECTION($,(0,0,-1));
+#1564=AXIS2_PLACEMENT_3D($,#1561,#1562,#1563);
+#1565=CIRCLE($,#1564,8.255);
+#1566=TRIMMED_CURVE($,#1565,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1567=EDGE_CURVE($,#1483,#657,#1566,.T.);
+#1568=ORIENTED_EDGE($,$,$,#1567,.T.);
+#1569=ORIENTED_EDGE($,$,$,#662,.F.);
+#1570=CARTESIAN_POINT($,(-8.255,440.99226,8.25746000000001));
+#1571=DIRECTION($,(1,-0,-0));
+#1572=DIRECTION($,(0,-1,0));
+#1573=AXIS2_PLACEMENT_3D($,#1570,#1571,#1572);
+#1574=CIRCLE($,#1573,8.255);
+#1575=TRIMMED_CURVE($,#1574,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(1.5707963267949)),.T.,.PARAMETER.);
+#1576=EDGE_CURVE($,#655,#1491,#1575,.T.);
+#1577=ORIENTED_EDGE($,$,$,#1576,.T.);
+#1578=EDGE_LOOP($,(#1560,#1568,#1569,#1577));
+#1579=FACE_OUTER_BOUND('',#1578,.T.);
+#1580=ADVANCED_FACE('',(#1579),#1559,.F.);
+#1581=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1582=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1583=DIRECTION($,(0,1,0));
+#1584=AXIS2_PLACEMENT_3D($,#1581,#1582,#1583);
+#1585=PLANE($,#1584);
+#1586=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1587=VERTEX_POINT($,#1586);
+#1588=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
#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));
+#1590=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#1591=DIRECTION($,(0,1,0));
+#1592=VECTOR($,#1591,1);
+#1593=LINE($,#1590,#1592);
+#1594=EDGE_CURVE($,#1587,#1589,#1593,.T.);
+#1595=ORIENTED_EDGE($,$,$,#1594,.T.);
+#1596=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#1597=VERTEX_POINT($,#1596);
+#1598=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
+#1599=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#1600=VECTOR($,#1599,1);
+#1601=LINE($,#1598,#1600);
+#1602=EDGE_CURVE($,#1589,#1597,#1601,.T.);
+#1603=ORIENTED_EDGE($,$,$,#1602,.T.);
+#1604=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#1605=VERTEX_POINT($,#1604);
+#1606=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#1607=DIRECTION($,(0,-1,0));
+#1608=VECTOR($,#1607,1);
+#1609=LINE($,#1606,#1608);
+#1610=EDGE_CURVE($,#1597,#1605,#1609,.T.);
+#1611=ORIENTED_EDGE($,$,$,#1610,.T.);
+#1612=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#1613=VERTEX_POINT($,#1612);
+#1614=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#1615=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#1616=VECTOR($,#1615,1);
+#1617=LINE($,#1614,#1616);
+#1618=EDGE_CURVE($,#1605,#1613,#1617,.T.);
+#1619=ORIENTED_EDGE($,$,$,#1618,.T.);
+#1620=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#1621=VERTEX_POINT($,#1620);
+#1622=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#1623=DIRECTION($,(0,-1,0));
+#1624=VECTOR($,#1623,1);
+#1625=LINE($,#1622,#1624);
+#1626=EDGE_CURVE($,#1613,#1621,#1625,.T.);
+#1627=ORIENTED_EDGE($,$,$,#1626,.T.);
+#1628=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#1629=VERTEX_POINT($,#1628);
+#1630=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#1631=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#1632=VECTOR($,#1631,1);
+#1633=LINE($,#1630,#1632);
+#1634=EDGE_CURVE($,#1621,#1629,#1633,.T.);
+#1635=ORIENTED_EDGE($,$,$,#1634,.T.);
+#1636=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#1637=VERTEX_POINT($,#1636);
+#1638=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#1639=DIRECTION($,(0,-1,0));
+#1640=VECTOR($,#1639,1);
+#1641=LINE($,#1638,#1640);
+#1642=EDGE_CURVE($,#1629,#1637,#1641,.T.);
+#1643=ORIENTED_EDGE($,$,$,#1642,.T.);
+#1644=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#1645=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#1646=VECTOR($,#1645,1);
+#1647=LINE($,#1644,#1646);
+#1648=EDGE_CURVE($,#1637,#1587,#1647,.T.);
+#1649=ORIENTED_EDGE($,$,$,#1648,.T.);
+#1650=EDGE_LOOP($,(#1595,#1603,#1611,#1619,#1627,#1635,#1643,#1649));
+#1651=FACE_OUTER_BOUND('',#1650,.T.);
+#1652=CARTESIAN_POINT($,(30.501323334841,258.15036,141.136596292231));
#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));
+#1654=CARTESIAN_POINT($,(30.501323334841,244.62486,141.136596292231));
+#1655=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1656=DIRECTION($,(0,1,0));
#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));
+#1658=CIRCLE($,#1657,13.5255);
+#1659=EDGE_CURVE($,#1653,#1653,#1658,.T.);
+#1660=ORIENTED_EDGE($,$,$,#1659,.T.);
+#1661=EDGE_LOOP($,(#1660));
+#1662=FACE_BOUND('',#1661,.T.);
+#1663=CARTESIAN_POINT($,(20.6230416016649,227.95611,131.258314559055));
+#1664=VERTEX_POINT($,#1663);
+#1665=CARTESIAN_POINT($,(20.6230416016649,225.57486,131.258314559055));
+#1666=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1667=DIRECTION($,(0,1,0));
+#1668=AXIS2_PLACEMENT_3D($,#1665,#1666,#1667);
+#1669=CIRCLE($,#1668,2.38125);
+#1670=EDGE_CURVE($,#1664,#1664,#1669,.T.);
+#1671=ORIENTED_EDGE($,$,$,#1670,.T.);
+#1672=EDGE_LOOP($,(#1671));
+#1673=FACE_BOUND('',#1672,.T.);
+#1674=CARTESIAN_POINT($,(20.6230416016649,266.05611,131.258314559055));
+#1675=VERTEX_POINT($,#1674);
+#1676=CARTESIAN_POINT($,(20.6230416016649,263.67486,131.258314559055));
+#1677=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1678=DIRECTION($,(0,1,0));
+#1679=AXIS2_PLACEMENT_3D($,#1676,#1677,#1678);
+#1680=CIRCLE($,#1679,2.38125);
+#1681=EDGE_CURVE($,#1675,#1675,#1680,.T.);
+#1682=ORIENTED_EDGE($,$,$,#1681,.T.);
+#1683=EDGE_LOOP($,(#1682));
+#1684=FACE_BOUND('',#1683,.T.);
+#1685=CARTESIAN_POINT($,(43.0736819043378,227.95611,153.708954861728));
+#1686=VERTEX_POINT($,#1685);
+#1687=CARTESIAN_POINT($,(43.0736819043378,225.57486,153.708954861728));
+#1688=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1689=DIRECTION($,(0,1,0));
+#1690=AXIS2_PLACEMENT_3D($,#1687,#1688,#1689);
+#1691=CIRCLE($,#1690,2.38125);
+#1692=EDGE_CURVE($,#1686,#1686,#1691,.T.);
+#1693=ORIENTED_EDGE($,$,$,#1692,.T.);
+#1694=EDGE_LOOP($,(#1693));
+#1695=FACE_BOUND('',#1694,.T.);
+#1696=CARTESIAN_POINT($,(43.0736819043378,266.05611,153.708954861728));
+#1697=VERTEX_POINT($,#1696);
+#1698=CARTESIAN_POINT($,(43.0736819043378,263.67486,153.708954861728));
+#1699=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1700=DIRECTION($,(0,1,0));
+#1701=AXIS2_PLACEMENT_3D($,#1698,#1699,#1700);
+#1702=CIRCLE($,#1701,2.38125);
+#1703=EDGE_CURVE($,#1697,#1697,#1702,.T.);
+#1704=ORIENTED_EDGE($,$,$,#1703,.T.);
+#1705=EDGE_LOOP($,(#1704));
+#1706=FACE_BOUND('',#1705,.T.);
+#1707=ADVANCED_FACE('',(#1651,#1662,#1673,#1684,#1695,#1706),#1585,.T.);
+#1708=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1709=DIRECTION($,(0.707106781186548,-0,-0.707106781186548));
+#1710=DIRECTION($,(0,1,0));
+#1711=AXIS2_PLACEMENT_3D($,#1708,#1709,#1710);
+#1712=PLANE($,#1711);
+#1713=CARTESIAN_POINT($,(44.4194503219496,181.12486,152.360646443019));
+#1714=VERTEX_POINT($,#1713);
+#1715=CARTESIAN_POINT($,(44.4194503219496,193.82486,152.360646443019));
+#1716=VERTEX_POINT($,#1715);
+#1717=CARTESIAN_POINT($,(44.4194503219496,181.12486,152.360646443019));
+#1718=DIRECTION($,(0,1,0));
+#1719=VECTOR($,#1718,1);
+#1720=LINE($,#1717,#1719);
+#1721=EDGE_CURVE($,#1714,#1716,#1720,.T.);
+#1722=ORIENTED_EDGE($,$,$,#1721,.T.);
+#1723=CARTESIAN_POINT($,(53.3997064430187,193.82486,161.340902564088));
+#1724=VERTEX_POINT($,#1723);
+#1725=CARTESIAN_POINT($,(44.4194503219496,193.82486,152.360646443019));
+#1726=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#1727=VECTOR($,#1726,1);
+#1728=LINE($,#1725,#1727);
+#1729=EDGE_CURVE($,#1716,#1724,#1728,.T.);
+#1730=ORIENTED_EDGE($,$,$,#1729,.T.);
+#1731=CARTESIAN_POINT($,(53.3997064430187,295.42486,161.340902564088));
+#1732=VERTEX_POINT($,#1731);
+#1733=CARTESIAN_POINT($,(53.3997064430187,193.82486,161.340902564088));
+#1734=DIRECTION($,(0,1,0));
+#1735=VECTOR($,#1734,1);
+#1736=LINE($,#1733,#1735);
+#1737=EDGE_CURVE($,#1724,#1732,#1736,.T.);
+#1738=ORIENTED_EDGE($,$,$,#1737,.T.);
+#1739=CARTESIAN_POINT($,(44.4194503219496,295.42486,152.360646443019));
+#1740=VERTEX_POINT($,#1739);
+#1741=CARTESIAN_POINT($,(53.3997064430187,295.42486,161.340902564088));
+#1742=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#1743=VECTOR($,#1742,1);
+#1744=LINE($,#1741,#1743);
+#1745=EDGE_CURVE($,#1732,#1740,#1744,.T.);
+#1746=ORIENTED_EDGE($,$,$,#1745,.T.);
+#1747=CARTESIAN_POINT($,(44.4194503219496,308.12486,152.360646443019));
+#1748=VERTEX_POINT($,#1747);
+#1749=CARTESIAN_POINT($,(44.4194503219496,295.42486,152.360646443019));
+#1750=DIRECTION($,(0,1,0));
+#1751=VECTOR($,#1750,1);
+#1752=LINE($,#1749,#1751);
+#1753=EDGE_CURVE($,#1740,#1748,#1752,.T.);
+#1754=ORIENTED_EDGE($,$,$,#1753,.T.);
+#1755=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#1756=VERTEX_POINT($,#1755);
+#1757=CARTESIAN_POINT($,(44.4194503219496,308.12486,152.360646443019));
+#1758=DIRECTION($,(-0.707106781186547,0,-0.707106781186548));
+#1759=VECTOR($,#1758,1);
+#1760=LINE($,#1757,#1759);
+#1761=EDGE_CURVE($,#1748,#1756,#1760,.T.);
+#1762=ORIENTED_EDGE($,$,$,#1761,.T.);
+#1763=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1764=VERTEX_POINT($,#1763);
+#1765=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#1766=DIRECTION($,(0,-1,0));
+#1767=VECTOR($,#1766,1);
+#1768=LINE($,#1765,#1767);
+#1769=EDGE_CURVE($,#1756,#1764,#1768,.T.);
+#1770=ORIENTED_EDGE($,$,$,#1769,.T.);
+#1771=CARTESIAN_POINT($,(10.1148719394654,181.12486,118.056068060535));
+#1772=DIRECTION($,(0.707106781186547,0,0.707106781186548));
+#1773=VECTOR($,#1772,1);
+#1774=LINE($,#1771,#1773);
+#1775=EDGE_CURVE($,#1764,#1714,#1774,.T.);
+#1776=ORIENTED_EDGE($,$,$,#1775,.T.);
+#1777=EDGE_LOOP($,(#1722,#1730,#1738,#1746,#1754,#1762,#1770,#1776));
+#1778=FACE_OUTER_BOUND('',#1777,.T.);
+#1779=CARTESIAN_POINT($,(31.8483617530013,258.15036,139.789557874071));
+#1780=VERTEX_POINT($,#1779);
+#1781=CARTESIAN_POINT($,(31.8483617530013,244.62486,139.789557874071));
+#1782=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1783=DIRECTION($,(0,1,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));
+#1785=CIRCLE($,#1784,13.5255);
+#1786=EDGE_CURVE($,#1780,#1780,#1785,.T.);
+#1787=ORIENTED_EDGE($,$,$,#1786,.T.);
+#1788=EDGE_LOOP($,(#1787));
+#1789=FACE_BOUND('',#1788,.T.);
+#1790=CARTESIAN_POINT($,(21.9700800198253,227.95611,129.911276140894));
+#1791=VERTEX_POINT($,#1790);
+#1792=CARTESIAN_POINT($,(21.9700800198253,225.57486,129.911276140894));
+#1793=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1794=DIRECTION($,(0,1,0));
+#1795=AXIS2_PLACEMENT_3D($,#1792,#1793,#1794);
+#1796=CIRCLE($,#1795,2.38125);
+#1797=EDGE_CURVE($,#1791,#1791,#1796,.T.);
+#1798=ORIENTED_EDGE($,$,$,#1797,.T.);
+#1799=EDGE_LOOP($,(#1798));
+#1800=FACE_BOUND('',#1799,.T.);
+#1801=CARTESIAN_POINT($,(21.9700800198253,266.05611,129.911276140894));
+#1802=VERTEX_POINT($,#1801);
+#1803=CARTESIAN_POINT($,(21.9700800198253,263.67486,129.911276140894));
+#1804=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#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));
+#1807=CIRCLE($,#1806,2.38125);
+#1808=EDGE_CURVE($,#1802,#1802,#1807,.T.);
+#1809=ORIENTED_EDGE($,$,$,#1808,.T.);
+#1810=EDGE_LOOP($,(#1809));
+#1811=FACE_BOUND('',#1810,.T.);
+#1812=CARTESIAN_POINT($,(44.4207203224982,227.95611,152.361916443567));
+#1813=VERTEX_POINT($,#1812);
+#1814=CARTESIAN_POINT($,(44.4207203224982,225.57486,152.361916443567));
+#1815=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1816=DIRECTION($,(0,1,0));
+#1817=AXIS2_PLACEMENT_3D($,#1814,#1815,#1816);
+#1818=CIRCLE($,#1817,2.38125);
+#1819=EDGE_CURVE($,#1813,#1813,#1818,.T.);
+#1820=ORIENTED_EDGE($,$,$,#1819,.T.);
+#1821=EDGE_LOOP($,(#1820));
+#1822=FACE_BOUND('',#1821,.T.);
+#1823=CARTESIAN_POINT($,(44.4207203224982,266.05611,152.361916443567));
+#1824=VERTEX_POINT($,#1823);
+#1825=CARTESIAN_POINT($,(44.4207203224982,263.67486,152.361916443567));
+#1826=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#1827=DIRECTION($,(0,1,0));
+#1828=AXIS2_PLACEMENT_3D($,#1825,#1826,#1827);
+#1829=CIRCLE($,#1828,2.38125);
+#1830=EDGE_CURVE($,#1824,#1824,#1829,.T.);
+#1831=ORIENTED_EDGE($,$,$,#1830,.T.);
+#1832=EDGE_LOOP($,(#1831));
+#1833=FACE_BOUND('',#1832,.T.);
+#1834=ADVANCED_FACE('',(#1778,#1789,#1800,#1811,#1822,#1833),#1712,.F.);
+#1835=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1836=DIRECTION($,(0,1,0));
+#1837=DIRECTION($,(-1,0,0));
+#1838=AXIS2_PLACEMENT_3D($,#1835,#1836,#1837);
+#1839=CYLINDRICAL_SURFACE($,#1838,8.255);
+#1840=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#1841=VERTEX_POINT($,#1840);
+#1842=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#1843=VERTEX_POINT($,#1842);
+#1844=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#1845=DIRECTION($,(0,1,0));
+#1846=VECTOR($,#1845,1);
+#1847=LINE($,#1844,#1846);
+#1848=EDGE_CURVE($,#1841,#1843,#1847,.T.);
+#1849=ORIENTED_EDGE($,$,$,#1848,.T.);
+#1850=CARTESIAN_POINT($,(14.605,308.12486,113.56594));
+#1851=DIRECTION($,(0,1,0));
+#1852=DIRECTION($,(-1,0,0));
+#1853=AXIS2_PLACEMENT_3D($,#1850,#1851,#1852);
+#1854=CIRCLE($,#1853,8.255);
+#1855=TRIMMED_CURVE($,#1854,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1856=EDGE_CURVE($,#1843,#1589,#1855,.T.);
+#1857=ORIENTED_EDGE($,$,$,#1856,.T.);
+#1858=ORIENTED_EDGE($,$,$,#1594,.F.);
+#1859=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1860=DIRECTION($,(-0,-1,-0));
+#1861=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
#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));
+#1863=CIRCLE($,#1862,8.255);
+#1864=TRIMMED_CURVE($,#1863,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.785398163397449)),.T.,.PARAMETER.);
+#1865=EDGE_CURVE($,#1587,#1841,#1864,.T.);
+#1866=ORIENTED_EDGE($,$,$,#1865,.T.);
+#1867=EDGE_LOOP($,(#1849,#1857,#1858,#1866));
+#1868=FACE_OUTER_BOUND('',#1867,.T.);
+#1869=ADVANCED_FACE('',(#1868),#1839,.T.);
+#1870=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1871=DIRECTION($,(0,1,0));
+#1872=DIRECTION($,(-1,0,0));
+#1873=AXIS2_PLACEMENT_3D($,#1870,#1871,#1872);
+#1874=CYLINDRICAL_SURFACE($,#1873,6.35);
+#1875=ORIENTED_EDGE($,$,$,#1769,.F.);
+#1876=CARTESIAN_POINT($,(8.25499999999999,308.12486,113.56594));
+#1877=VERTEX_POINT($,#1876);
+#1878=CARTESIAN_POINT($,(14.605,308.12486,113.56594));
+#1879=DIRECTION($,(-0,-1,-0));
+#1880=DIRECTION($,(-0.707106781186547,0,0.707106781186548));
+#1881=AXIS2_PLACEMENT_3D($,#1878,#1879,#1880);
+#1882=CIRCLE($,#1881,6.35000000000001);
+#1883=TRIMMED_CURVE($,#1882,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1884=EDGE_CURVE($,#1756,#1877,#1883,.T.);
+#1885=ORIENTED_EDGE($,$,$,#1884,.T.);
+#1886=CARTESIAN_POINT($,(8.255,181.12486,113.56594));
+#1887=VERTEX_POINT($,#1886);
+#1888=CARTESIAN_POINT($,(8.25499999999999,308.12486,113.56594));
+#1889=DIRECTION($,(0,-1,0));
+#1890=VECTOR($,#1889,1);
+#1891=LINE($,#1888,#1890);
+#1892=EDGE_CURVE($,#1877,#1887,#1891,.T.);
+#1893=ORIENTED_EDGE($,$,$,#1892,.T.);
+#1894=CARTESIAN_POINT($,(14.605,181.12486,113.56594));
+#1895=DIRECTION($,(0,1,0));
+#1896=DIRECTION($,(-1,0,0));
+#1897=AXIS2_PLACEMENT_3D($,#1894,#1895,#1896);
+#1898=CIRCLE($,#1897,6.35);
+#1899=TRIMMED_CURVE($,#1898,(PARAMETER_VALUE(0)),(PARAMETER_VALUE(0.78539816339745)),.T.,.PARAMETER.);
+#1900=EDGE_CURVE($,#1887,#1764,#1899,.T.);
+#1901=ORIENTED_EDGE($,$,$,#1900,.T.);
+#1902=EDGE_LOOP($,(#1875,#1885,#1893,#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));
+#1904=ADVANCED_FACE('',(#1903),#1874,.F.);
+#1905=CARTESIAN_POINT($,(-241.3,58.08726,78.105));
+#1906=DIRECTION($,(-0,1,0));
+#1907=DIRECTION($,(1,0,0));
#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));
+#1910=ORIENTED_EDGE($,$,$,#14,.T.);
+#1911=CARTESIAN_POINT($,(-233.045,58.08726,78.105));
+#1912=DIRECTION($,(0,0,-1));
#1913=VECTOR($,#1912,1);
#1914=LINE($,#1911,#1913);
-#1915=EDGE_CURVE($,#625,#657,#1914,.T.);
+#1915=EDGE_CURVE($,#9,#319,#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));
+#1917=ORIENTED_EDGE($,$,$,#332,.T.);
+#1918=CARTESIAN_POINT($,(-241.3,58.08726,76.2));
+#1919=DIRECTION($,(0,0,1));
#1920=VECTOR($,#1919,1);
#1921=LINE($,#1918,#1920);
-#1922=EDGE_CURVE($,#665,#617,#1921,.T.);
+#1922=EDGE_CURVE($,#327,#7,#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));
+#1927=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#1928=DIRECTION($,(-0,1,0));
+#1929=DIRECTION($,(1,0,0));
#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));
+#1932=ORIENTED_EDGE($,$,$,#30,.T.);
+#1933=CARTESIAN_POINT($,(0,58.08726,78.105));
+#1934=DIRECTION($,(0,0,-1));
#1935=VECTOR($,#1934,1);
#1936=LINE($,#1933,#1935);
-#1937=EDGE_CURVE($,#615,#673,#1936,.T.);
+#1937=EDGE_CURVE($,#25,#303,#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));
+#1939=ORIENTED_EDGE($,$,$,#316,.T.);
+#1940=CARTESIAN_POINT($,(-8.255,58.08726,76.2));
+#1941=DIRECTION($,(0,0,1));
#1942=VECTOR($,#1941,1);
#1943=LINE($,#1940,#1942);
-#1944=EDGE_CURVE($,#655,#633,#1943,.T.);
+#1944=EDGE_CURVE($,#311,#17,#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));
+#1949=CARTESIAN_POINT($,(0,58.08726,78.105));
#1950=DIRECTION($,(-1,0,0));
-#1951=DIRECTION($,(0,0.707106781186548,-0.707106781186548));
+#1951=DIRECTION($,(0,1,0));
#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));
+#1954=ORIENTED_EDGE($,$,$,#38,.T.);
+#1955=CARTESIAN_POINT($,(0,66.34226,78.105));
+#1956=DIRECTION($,(0,0,-1));
+#1957=VECTOR($,#1956,1);
+#1958=LINE($,#1955,#1957);
+#1959=EDGE_CURVE($,#33,#295,#1958,.T.);
+#1960=ORIENTED_EDGE($,$,$,#1959,.T.);
+#1961=ORIENTED_EDGE($,$,$,#308,.T.);
+#1962=ORIENTED_EDGE($,$,$,#1937,.F.);
+#1963=EDGE_LOOP($,(#1954,#1960,#1961,#1962));
+#1964=FACE_OUTER_BOUND('',#1963,.T.);
+#1965=ADVANCED_FACE('',(#1964),#1953,.T.);
+#1966=CARTESIAN_POINT($,(0,418.13226,78.105));
+#1967=DIRECTION($,(-1,0,0));
+#1968=DIRECTION($,(0,1,0));
+#1969=AXIS2_PLACEMENT_3D($,#1966,#1967,#1968);
+#1970=PLANE($,#1969);
+#1971=ORIENTED_EDGE($,$,$,#54,.T.);
+#1972=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1973=DIRECTION($,(0,0,-1));
+#1974=VECTOR($,#1973,1);
+#1975=LINE($,#1972,#1974);
+#1976=EDGE_CURVE($,#49,#279,#1975,.T.);
+#1977=ORIENTED_EDGE($,$,$,#1976,.T.);
+#1978=ORIENTED_EDGE($,$,$,#292,.T.);
+#1979=CARTESIAN_POINT($,(0,418.13226,76.2));
+#1980=DIRECTION($,(0,0,1));
#1981=VECTOR($,#1980,1);
#1982=LINE($,#1979,#1981);
-#1983=EDGE_CURVE($,#757,#789,#1982,.T.);
+#1983=EDGE_CURVE($,#287,#41,#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));
+#1985=EDGE_LOOP($,(#1971,#1977,#1978,#1984));
+#1986=FACE_OUTER_BOUND('',#1985,.T.);
+#1987=ADVANCED_FACE('',(#1986),#1970,.T.);
+#1988=CARTESIAN_POINT($,(0,426.38726,78.105));
+#1989=DIRECTION($,(-0,-1,-0));
+#1990=DIRECTION($,(-1,0,0));
+#1991=AXIS2_PLACEMENT_3D($,#1988,#1989,#1990);
+#1992=PLANE($,#1991);
+#1993=ORIENTED_EDGE($,$,$,#62,.T.);
+#1994=CARTESIAN_POINT($,(-8.255,426.38726,78.105));
+#1995=DIRECTION($,(0,0,-1));
+#1996=VECTOR($,#1995,1);
+#1997=LINE($,#1994,#1996);
+#1998=EDGE_CURVE($,#57,#271,#1997,.T.);
+#1999=ORIENTED_EDGE($,$,$,#1998,.T.);
+#2000=ORIENTED_EDGE($,$,$,#284,.T.);
+#2001=ORIENTED_EDGE($,$,$,#1976,.F.);
+#2002=EDGE_LOOP($,(#1993,#1999,#2000,#2001));
+#2003=FACE_OUTER_BOUND('',#2002,.T.);
+#2004=ADVANCED_FACE('',(#2003),#1992,.T.);
+#2005=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#2006=DIRECTION($,(-0,-1,-0));
+#2007=DIRECTION($,(-1,0,0));
+#2008=AXIS2_PLACEMENT_3D($,#2005,#2006,#2007);
+#2009=PLANE($,#2008);
+#2010=ORIENTED_EDGE($,$,$,#78,.T.);
+#2011=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#2012=DIRECTION($,(0,0,-1));
+#2013=VECTOR($,#2012,1);
+#2014=LINE($,#2011,#2013);
+#2015=EDGE_CURVE($,#73,#255,#2014,.T.);
+#2016=ORIENTED_EDGE($,$,$,#2015,.T.);
+#2017=ORIENTED_EDGE($,$,$,#268,.T.);
+#2018=CARTESIAN_POINT($,(-233.045,426.38726,76.2));
+#2019=DIRECTION($,(0,0,1));
#2020=VECTOR($,#2019,1);
#2021=LINE($,#2018,#2020);
-#2022=EDGE_CURVE($,#747,#805,#2021,.T.);
+#2022=EDGE_CURVE($,#263,#65,#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));
+#2024=EDGE_LOOP($,(#2010,#2016,#2017,#2023));
+#2025=FACE_OUTER_BOUND('',#2024,.T.);
+#2026=ADVANCED_FACE('',(#2025),#2009,.T.);
+#2027=CARTESIAN_POINT($,(-241.3,426.38726,78.105));
+#2028=DIRECTION($,(1,0,0));
+#2029=DIRECTION($,(0,-1,0));
+#2030=AXIS2_PLACEMENT_3D($,#2027,#2028,#2029);
+#2031=PLANE($,#2030);
+#2032=ORIENTED_EDGE($,$,$,#86,.T.);
+#2033=CARTESIAN_POINT($,(-241.3,418.13226,78.105));
+#2034=DIRECTION($,(0,0,-1));
+#2035=VECTOR($,#2034,1);
+#2036=LINE($,#2033,#2035);
+#2037=EDGE_CURVE($,#81,#247,#2036,.T.);
+#2038=ORIENTED_EDGE($,$,$,#2037,.T.);
+#2039=ORIENTED_EDGE($,$,$,#260,.T.);
+#2040=ORIENTED_EDGE($,$,$,#2015,.F.);
+#2041=EDGE_LOOP($,(#2032,#2038,#2039,#2040));
+#2042=FACE_OUTER_BOUND('',#2041,.T.);
+#2043=ADVANCED_FACE('',(#2042),#2031,.T.);
+#2044=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#2045=DIRECTION($,(1,0,0));
+#2046=DIRECTION($,(0,-1,0));
+#2047=AXIS2_PLACEMENT_3D($,#2044,#2045,#2046);
+#2048=PLANE($,#2047);
+#2049=ORIENTED_EDGE($,$,$,#100,.T.);
+#2050=ORIENTED_EDGE($,$,$,#1922,.F.);
+#2051=ORIENTED_EDGE($,$,$,#338,.T.);
+#2052=CARTESIAN_POINT($,(-241.3,66.34226,76.2));
+#2053=DIRECTION($,(0,0,1));
+#2054=VECTOR($,#2053,1);
+#2055=LINE($,#2052,#2054);
+#2056=EDGE_CURVE($,#245,#89,#2055,.T.);
+#2057=ORIENTED_EDGE($,$,$,#2056,.T.);
+#2058=EDGE_LOOP($,(#2049,#2050,#2051,#2057));
+#2059=FACE_OUTER_BOUND('',#2058,.T.);
+#2060=ADVANCED_FACE('',(#2059),#2048,.T.);
+#2061=CARTESIAN_POINT($,(-8.255,49.83226,69.85));
+#2062=DIRECTION($,(1,-0,0));
+#2063=DIRECTION($,(0,-0,-1));
+#2064=AXIS2_PLACEMENT_3D($,#2061,#2062,#2063);
+#2065=PLANE($,#2064);
+#2066=ORIENTED_EDGE($,$,$,#498,.T.);
+#2067=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#2068=DIRECTION($,(0,1,0));
+#2069=VECTOR($,#2068,1);
+#2070=LINE($,#2067,#2069);
+#2071=EDGE_CURVE($,#493,#525,#2070,.T.);
+#2072=ORIENTED_EDGE($,$,$,#2071,.T.);
+#2073=ORIENTED_EDGE($,$,$,#538,.T.);
+#2074=CARTESIAN_POINT($,(-8.255,51.73726,69.85));
+#2075=DIRECTION($,(0,-1,0));
+#2076=VECTOR($,#2075,1);
+#2077=LINE($,#2074,#2076);
+#2078=EDGE_CURVE($,#533,#485,#2077,.T.);
+#2079=ORIENTED_EDGE($,$,$,#2078,.T.);
+#2080=EDGE_LOOP($,(#2066,#2072,#2073,#2079));
+#2081=FACE_OUTER_BOUND('',#2080,.T.);
+#2082=ADVANCED_FACE('',(#2081),#2065,.T.);
+#2083=CARTESIAN_POINT($,(-233.045,49.83226,8.25746000000001));
+#2084=DIRECTION($,(-1,0,0));
+#2085=DIRECTION($,(0,0,1));
+#2086=AXIS2_PLACEMENT_3D($,#2083,#2084,#2085);
+#2087=PLANE($,#2086);
+#2088=ORIENTED_EDGE($,$,$,#512,.T.);
+#2089=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#2090=DIRECTION($,(0,1,0));
+#2091=VECTOR($,#2090,1);
+#2092=LINE($,#2089,#2091);
+#2093=EDGE_CURVE($,#483,#541,#2092,.T.);
+#2094=ORIENTED_EDGE($,$,$,#2093,.T.);
+#2095=ORIENTED_EDGE($,$,$,#552,.T.);
+#2096=CARTESIAN_POINT($,(-233.045,51.73726,8.25746000000001));
+#2097=DIRECTION($,(0,-1,0));
+#2098=VECTOR($,#2097,1);
+#2099=LINE($,#2096,#2098);
+#2100=EDGE_CURVE($,#523,#501,#2099,.T.);
+#2101=ORIENTED_EDGE($,$,$,#2100,.T.);
+#2102=EDGE_LOOP($,(#2088,#2094,#2095,#2101));
+#2103=FACE_OUTER_BOUND('',#2102,.T.);
+#2104=ADVANCED_FACE('',(#2103),#2087,.T.);
+#2105=CARTESIAN_POINT($,(-8.255,58.08726,78.105));
+#2106=DIRECTION($,(1,0,0));
+#2107=DIRECTION($,(0,-0.707106781186548,-0.707106781186547));
+#2108=AXIS2_PLACEMENT_3D($,#2105,#2106,#2107);
+#2109=PLANE($,#2108);
+#2110=ORIENTED_EDGE($,$,$,#569,.T.);
+#2111=ORIENTED_EDGE($,$,$,#2078,.F.);
+#2112=ORIENTED_EDGE($,$,$,#595,.T.);
+#2113=ORIENTED_EDGE($,$,$,#1944,.T.);
+#2114=EDGE_LOOP($,(#2110,#2111,#2112,#2113));
+#2115=FACE_OUTER_BOUND('',#2114,.T.);
+#2116=ADVANCED_FACE('',(#2115),#2109,.T.);
+#2117=CARTESIAN_POINT($,(-233.045,49.83226,69.85));
+#2118=DIRECTION($,(-1,0,0));
+#2119=DIRECTION($,(0,0.707106781186548,0.707106781186547));
+#2120=AXIS2_PLACEMENT_3D($,#2117,#2118,#2119);
+#2121=PLANE($,#2120);
+#2122=ORIENTED_EDGE($,$,$,#578,.T.);
+#2123=ORIENTED_EDGE($,$,$,#1915,.T.);
+#2124=ORIENTED_EDGE($,$,$,#604,.T.);
+#2125=ORIENTED_EDGE($,$,$,#2093,.F.);
+#2126=EDGE_LOOP($,(#2122,#2123,#2124,#2125));
+#2127=FACE_OUTER_BOUND('',#2126,.T.);
+#2128=ADVANCED_FACE('',(#2127),#2121,.T.);
+#2129=CARTESIAN_POINT($,(-233.045,434.64226,69.85));
+#2130=DIRECTION($,(-1,-0,-0));
+#2131=DIRECTION($,(0,0,-1));
+#2132=AXIS2_PLACEMENT_3D($,#2129,#2130,#2131);
+#2133=PLANE($,#2132);
+#2134=ORIENTED_EDGE($,$,$,#630,.T.);
+#2135=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#2136=DIRECTION($,(0,-1,0));
+#2137=VECTOR($,#2136,1);
+#2138=LINE($,#2135,#2137);
+#2139=EDGE_CURVE($,#625,#657,#2138,.T.);
+#2140=ORIENTED_EDGE($,$,$,#2139,.T.);
+#2141=ORIENTED_EDGE($,$,$,#670,.T.);
+#2142=CARTESIAN_POINT($,(-233.045,432.73726,69.85));
+#2143=DIRECTION($,(0,1,0));
+#2144=VECTOR($,#2143,1);
+#2145=LINE($,#2142,#2144);
+#2146=EDGE_CURVE($,#665,#617,#2145,.T.);
+#2147=ORIENTED_EDGE($,$,$,#2146,.T.);
+#2148=EDGE_LOOP($,(#2134,#2140,#2141,#2147));
+#2149=FACE_OUTER_BOUND('',#2148,.T.);
+#2150=ADVANCED_FACE('',(#2149),#2133,.T.);
+#2151=CARTESIAN_POINT($,(-8.255,434.64226,8.25746000000001));
+#2152=DIRECTION($,(1,0,-0));
+#2153=DIRECTION($,(0,0,1));
+#2154=AXIS2_PLACEMENT_3D($,#2151,#2152,#2153);
+#2155=PLANE($,#2154);
+#2156=ORIENTED_EDGE($,$,$,#644,.T.);
+#2157=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#2158=DIRECTION($,(0,-1,0));
+#2159=VECTOR($,#2158,1);
+#2160=LINE($,#2157,#2159);
+#2161=EDGE_CURVE($,#615,#673,#2160,.T.);
+#2162=ORIENTED_EDGE($,$,$,#2161,.T.);
+#2163=ORIENTED_EDGE($,$,$,#684,.T.);
+#2164=CARTESIAN_POINT($,(-8.255,432.73726,8.25746000000001));
+#2165=DIRECTION($,(0,1,0));
+#2166=VECTOR($,#2165,1);
+#2167=LINE($,#2164,#2166);
+#2168=EDGE_CURVE($,#655,#633,#2167,.T.);
+#2169=ORIENTED_EDGE($,$,$,#2168,.T.);
+#2170=EDGE_LOOP($,(#2156,#2162,#2163,#2169));
+#2171=FACE_OUTER_BOUND('',#2170,.T.);
+#2172=ADVANCED_FACE('',(#2171),#2155,.T.);
+#2173=CARTESIAN_POINT($,(-233.045,426.38726,78.105));
+#2174=DIRECTION($,(-1,0,0));
+#2175=DIRECTION($,(0,0.707106781186548,-0.707106781186548));
+#2176=AXIS2_PLACEMENT_3D($,#2173,#2174,#2175);
+#2177=PLANE($,#2176);
+#2178=ORIENTED_EDGE($,$,$,#701,.T.);
+#2179=ORIENTED_EDGE($,$,$,#2146,.F.);
+#2180=ORIENTED_EDGE($,$,$,#727,.T.);
+#2181=ORIENTED_EDGE($,$,$,#2022,.T.);
+#2182=EDGE_LOOP($,(#2178,#2179,#2180,#2181));
+#2183=FACE_OUTER_BOUND('',#2182,.T.);
+#2184=ADVANCED_FACE('',(#2183),#2177,.T.);
+#2185=CARTESIAN_POINT($,(-8.255,434.64226,69.85));
+#2186=DIRECTION($,(1,0,0));
+#2187=DIRECTION($,(0,-0.707106781186548,0.707106781186548));
+#2188=AXIS2_PLACEMENT_3D($,#2185,#2186,#2187);
+#2189=PLANE($,#2188);
+#2190=ORIENTED_EDGE($,$,$,#710,.T.);
+#2191=ORIENTED_EDGE($,$,$,#1998,.T.);
+#2192=ORIENTED_EDGE($,$,$,#736,.T.);
+#2193=ORIENTED_EDGE($,$,$,#2161,.F.);
+#2194=EDGE_LOOP($,(#2190,#2191,#2192,#2193));
+#2195=FACE_OUTER_BOUND('',#2194,.T.);
+#2196=ADVANCED_FACE('',(#2195),#2189,.T.);
+#2197=CARTESIAN_POINT($,(-247.65,66.34226,84.455));
+#2198=DIRECTION($,(0,-1,0));
+#2199=DIRECTION($,(0,0,1));
+#2200=AXIS2_PLACEMENT_3D($,#2197,#2198,#2199);
+#2201=PLANE($,#2200);
+#2202=ORIENTED_EDGE($,$,$,#762,.T.);
+#2203=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#2204=DIRECTION($,(-1,0,0));
+#2205=VECTOR($,#2204,1);
+#2206=LINE($,#2203,#2205);
+#2207=EDGE_CURVE($,#757,#789,#2206,.T.);
+#2208=ORIENTED_EDGE($,$,$,#2207,.T.);
+#2209=ORIENTED_EDGE($,$,$,#802,.T.);
+#2210=CARTESIAN_POINT($,(-249.555,66.34226,84.455));
+#2211=DIRECTION($,(1,0,0));
+#2212=VECTOR($,#2211,1);
+#2213=LINE($,#2210,#2212);
+#2214=EDGE_CURVE($,#797,#749,#2213,.T.);
+#2215=ORIENTED_EDGE($,$,$,#2214,.T.);
+#2216=EDGE_LOOP($,(#2202,#2208,#2209,#2215));
+#2217=FACE_OUTER_BOUND('',#2216,.T.);
+#2218=ADVANCED_FACE('',(#2217),#2201,.T.);
+#2219=CARTESIAN_POINT($,(-247.65,66.34226,128.905));
+#2220=DIRECTION($,(0,-0,1));
+#2221=DIRECTION($,(0,1,0));
+#2222=AXIS2_PLACEMENT_3D($,#2219,#2220,#2221);
+#2223=PLANE($,#2222);
+#2224=ORIENTED_EDGE($,$,$,#770,.T.);
+#2225=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#2226=DIRECTION($,(-1,0,0));
+#2227=VECTOR($,#2226,1);
+#2228=LINE($,#2225,#2227);
+#2229=EDGE_CURVE($,#765,#787,#2228,.T.);
+#2230=ORIENTED_EDGE($,$,$,#2229,.T.);
+#2231=ORIENTED_EDGE($,$,$,#794,.T.);
+#2232=ORIENTED_EDGE($,$,$,#2207,.F.);
+#2233=EDGE_LOOP($,(#2224,#2230,#2231,#2232));
+#2234=FACE_OUTER_BOUND('',#2233,.T.);
+#2235=ADVANCED_FACE('',(#2234),#2223,.T.);
+#2236=CARTESIAN_POINT($,(-247.65,418.13226,128.905));
+#2237=DIRECTION($,(0,1,0));
+#2238=DIRECTION($,(0,0,-1));
+#2239=AXIS2_PLACEMENT_3D($,#2236,#2237,#2238);
+#2240=PLANE($,#2239);
+#2241=ORIENTED_EDGE($,$,$,#776,.T.);
+#2242=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#2243=DIRECTION($,(-1,0,0));
+#2244=VECTOR($,#2243,1);
+#2245=LINE($,#2242,#2244);
+#2246=EDGE_CURVE($,#747,#805,#2245,.T.);
+#2247=ORIENTED_EDGE($,$,$,#2246,.T.);
+#2248=ORIENTED_EDGE($,$,$,#816,.T.);
+#2249=ORIENTED_EDGE($,$,$,#2229,.F.);
+#2250=EDGE_LOOP($,(#2241,#2247,#2248,#2249));
+#2251=FACE_OUTER_BOUND('',#2250,.T.);
+#2252=ADVANCED_FACE('',(#2251),#2240,.T.);
+#2253=CARTESIAN_POINT($,(-241.3,66.34226,78.105));
+#2254=DIRECTION($,(-0,-1,-0));
+#2255=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#2256=AXIS2_PLACEMENT_3D($,#2253,#2254,#2255);
+#2257=PLANE($,#2256);
+#2258=ORIENTED_EDGE($,$,$,#833,.T.);
+#2259=ORIENTED_EDGE($,$,$,#2214,.F.);
+#2260=ORIENTED_EDGE($,$,$,#859,.T.);
+#2261=ORIENTED_EDGE($,$,$,#2056,.T.);
+#2262=EDGE_LOOP($,(#2258,#2259,#2260,#2261));
+#2263=FACE_OUTER_BOUND('',#2262,.T.);
+#2264=ADVANCED_FACE('',(#2263),#2257,.T.);
+#2265=CARTESIAN_POINT($,(-247.65,418.13226,84.455));
+#2266=DIRECTION($,(0,1,0));
+#2267=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#2268=AXIS2_PLACEMENT_3D($,#2265,#2266,#2267);
+#2269=PLANE($,#2268);
+#2270=ORIENTED_EDGE($,$,$,#842,.T.);
+#2271=ORIENTED_EDGE($,$,$,#2037,.T.);
+#2272=ORIENTED_EDGE($,$,$,#868,.T.);
+#2273=ORIENTED_EDGE($,$,$,#2246,.F.);
+#2274=EDGE_LOOP($,(#2270,#2271,#2272,#2273));
+#2275=FACE_OUTER_BOUND('',#2274,.T.);
+#2276=ADVANCED_FACE('',(#2275),#2269,.T.);
+#2277=CARTESIAN_POINT($,(6.35,418.13226,84.455));
+#2278=DIRECTION($,(0,1,0));
+#2279=DIRECTION($,(0,0,1));
+#2280=AXIS2_PLACEMENT_3D($,#2277,#2278,#2279);
+#2281=PLANE($,#2280);
+#2282=ORIENTED_EDGE($,$,$,#894,.T.);
+#2283=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#2284=DIRECTION($,(1,0,0));
+#2285=VECTOR($,#2284,1);
+#2286=LINE($,#2283,#2285);
+#2287=EDGE_CURVE($,#889,#921,#2286,.T.);
+#2288=ORIENTED_EDGE($,$,$,#2287,.T.);
+#2289=ORIENTED_EDGE($,$,$,#934,.T.);
+#2290=CARTESIAN_POINT($,(8.255,418.13226,84.455));
+#2291=DIRECTION($,(-1,0,0));
+#2292=VECTOR($,#2291,1);
+#2293=LINE($,#2290,#2292);
+#2294=EDGE_CURVE($,#929,#881,#2293,.T.);
+#2295=ORIENTED_EDGE($,$,$,#2294,.T.);
+#2296=EDGE_LOOP($,(#2282,#2288,#2289,#2295));
+#2297=FACE_OUTER_BOUND('',#2296,.T.);
+#2298=ADVANCED_FACE('',(#2297),#2281,.T.);
+#2299=CARTESIAN_POINT($,(6.35,418.13226,113.56594));
+#2300=DIRECTION($,(-0,0,1));
+#2301=DIRECTION($,(0,-1,0));
+#2302=AXIS2_PLACEMENT_3D($,#2299,#2300,#2301);
+#2303=PLANE($,#2302);
+#2304=ORIENTED_EDGE($,$,$,#902,.T.);
+#2305=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#2306=DIRECTION($,(1,0,0));
+#2307=VECTOR($,#2306,1);
+#2308=LINE($,#2305,#2307);
+#2309=EDGE_CURVE($,#897,#919,#2308,.T.);
+#2310=ORIENTED_EDGE($,$,$,#2309,.T.);
+#2311=ORIENTED_EDGE($,$,$,#926,.T.);
+#2312=ORIENTED_EDGE($,$,$,#2287,.F.);
+#2313=EDGE_LOOP($,(#2304,#2310,#2311,#2312));
+#2314=FACE_OUTER_BOUND('',#2313,.T.);
+#2315=ADVANCED_FACE('',(#2314),#2303,.T.);
+#2316=CARTESIAN_POINT($,(6.35,66.34226,113.56594));
+#2317=DIRECTION($,(0,-1,-0));
+#2318=DIRECTION($,(-0,0,-1));
+#2319=AXIS2_PLACEMENT_3D($,#2316,#2317,#2318);
+#2320=PLANE($,#2319);
+#2321=ORIENTED_EDGE($,$,$,#908,.T.);
+#2322=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#2323=DIRECTION($,(1,0,0));
+#2324=VECTOR($,#2323,1);
+#2325=LINE($,#2322,#2324);
+#2326=EDGE_CURVE($,#879,#937,#2325,.T.);
+#2327=ORIENTED_EDGE($,$,$,#2326,.T.);
+#2328=ORIENTED_EDGE($,$,$,#948,.T.);
+#2329=ORIENTED_EDGE($,$,$,#2309,.F.);
+#2330=EDGE_LOOP($,(#2321,#2327,#2328,#2329));
+#2331=FACE_OUTER_BOUND('',#2330,.T.);
+#2332=ADVANCED_FACE('',(#2331),#2320,.T.);
+#2333=CARTESIAN_POINT($,(0,418.13226,78.105));
+#2334=DIRECTION($,(-0,1,0));
+#2335=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#2336=AXIS2_PLACEMENT_3D($,#2333,#2334,#2335);
+#2337=PLANE($,#2336);
+#2338=ORIENTED_EDGE($,$,$,#965,.T.);
+#2339=ORIENTED_EDGE($,$,$,#2294,.F.);
+#2340=ORIENTED_EDGE($,$,$,#991,.T.);
+#2341=ORIENTED_EDGE($,$,$,#1983,.T.);
+#2342=EDGE_LOOP($,(#2338,#2339,#2340,#2341));
+#2343=FACE_OUTER_BOUND('',#2342,.T.);
+#2344=ADVANCED_FACE('',(#2343),#2337,.T.);
+#2345=CARTESIAN_POINT($,(6.35,66.34226,84.455));
+#2346=DIRECTION($,(0,-1,-0));
+#2347=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#2348=AXIS2_PLACEMENT_3D($,#2345,#2346,#2347);
+#2349=PLANE($,#2348);
+#2350=ORIENTED_EDGE($,$,$,#974,.T.);
+#2351=ORIENTED_EDGE($,$,$,#1959,.T.);
+#2352=ORIENTED_EDGE($,$,$,#1000,.T.);
+#2353=ORIENTED_EDGE($,$,$,#2326,.F.);
+#2354=EDGE_LOOP($,(#2350,#2351,#2352,#2353));
+#2355=FACE_OUTER_BOUND('',#2354,.T.);
+#2356=ADVANCED_FACE('',(#2355),#2349,.T.);
+#2357=CARTESIAN_POINT($,(-8.255,43.48226,1.90746000000001));
+#2358=DIRECTION($,(1,0,0));
+#2359=DIRECTION($,(0,-1,0));
+#2360=AXIS2_PLACEMENT_3D($,#2357,#2358,#2359);
+#2361=PLANE($,#2360);
+#2362=ORIENTED_EDGE($,$,$,#1026,.T.);
+#2363=CARTESIAN_POINT($,(-8.255,0.002539999999996,1.90746000000001));
+#2364=DIRECTION($,(0,0,-1));
+#2365=VECTOR($,#2364,1);
+#2366=LINE($,#2363,#2365);
+#2367=EDGE_CURVE($,#1021,#1171,#2366,.T.);
+#2368=ORIENTED_EDGE($,$,$,#2367,.T.);
+#2369=ORIENTED_EDGE($,$,$,#1184,.T.);
+#2370=CARTESIAN_POINT($,(-8.255,43.48226,0.00246000000001));
+#2371=DIRECTION($,(0,0,1));
+#2372=VECTOR($,#2371,1);
+#2373=LINE($,#2370,#2372);
+#2374=EDGE_CURVE($,#1179,#1013,#2373,.T.);
+#2375=ORIENTED_EDGE($,$,$,#2374,.T.);
+#2376=EDGE_LOOP($,(#2362,#2368,#2369,#2375));
+#2377=FACE_OUTER_BOUND('',#2376,.T.);
+#2378=ADVANCED_FACE('',(#2377),#2361,.T.);
+#2379=CARTESIAN_POINT($,(-8.255,0.002539999999996,1.90746000000001));
+#2380=DIRECTION($,(-0,-1,-0));
+#2381=DIRECTION($,(-1,0,0));
+#2382=AXIS2_PLACEMENT_3D($,#2379,#2380,#2381);
+#2383=PLANE($,#2382);
+#2384=ORIENTED_EDGE($,$,$,#1034,.T.);
+#2385=CARTESIAN_POINT($,(-48.895,0.002539999999996,1.90746000000001));
+#2386=DIRECTION($,(0,0,-1));
+#2387=VECTOR($,#2386,1);
+#2388=LINE($,#2385,#2387);
+#2389=EDGE_CURVE($,#1029,#1163,#2388,.T.);
+#2390=ORIENTED_EDGE($,$,$,#2389,.T.);
+#2391=ORIENTED_EDGE($,$,$,#1176,.T.);
+#2392=ORIENTED_EDGE($,$,$,#2367,.F.);
+#2393=EDGE_LOOP($,(#2384,#2390,#2391,#2392));
+#2394=FACE_OUTER_BOUND('',#2393,.T.);
+#2395=ADVANCED_FACE('',(#2394),#2383,.T.);
+#2396=CARTESIAN_POINT($,(-48.895,0.002539999999996,1.90746000000001));
+#2397=DIRECTION($,(-1,0,0));
+#2398=DIRECTION($,(0,1,0));
+#2399=AXIS2_PLACEMENT_3D($,#2396,#2397,#2398);
+#2400=PLANE($,#2399);
+#2401=ORIENTED_EDGE($,$,$,#1042,.T.);
+#2402=CARTESIAN_POINT($,(-48.895,25.40254,1.90746000000001));
+#2403=DIRECTION($,(0,0,-1));
+#2404=VECTOR($,#2403,1);
+#2405=LINE($,#2402,#2404);
+#2406=EDGE_CURVE($,#1037,#1155,#2405,.T.);
+#2407=ORIENTED_EDGE($,$,$,#2406,.T.);
+#2408=ORIENTED_EDGE($,$,$,#1168,.T.);
+#2409=ORIENTED_EDGE($,$,$,#2389,.F.);
+#2410=EDGE_LOOP($,(#2401,#2407,#2408,#2409));
+#2411=FACE_OUTER_BOUND('',#2410,.T.);
+#2412=ADVANCED_FACE('',(#2411),#2400,.T.);
+#2413=CARTESIAN_POINT($,(-48.895,25.40254,1.90746000000001));
+#2414=DIRECTION($,(-0.707106781186547,-0.707106781186548,-0));
+#2415=DIRECTION($,(-0.707106781186548,0.707106781186547,0));
+#2416=AXIS2_PLACEMENT_3D($,#2413,#2414,#2415);
+#2417=PLANE($,#2416);
+#2418=ORIENTED_EDGE($,$,$,#1050,.T.);
+#2419=CARTESIAN_POINT($,(-55.245,31.75254,1.90746000000001));
+#2420=DIRECTION($,(0,0,-1));
+#2421=VECTOR($,#2420,1);
+#2422=LINE($,#2419,#2421);
+#2423=EDGE_CURVE($,#1045,#1147,#2422,.T.);
+#2424=ORIENTED_EDGE($,$,$,#2423,.T.);
+#2425=ORIENTED_EDGE($,$,$,#1160,.T.);
+#2426=ORIENTED_EDGE($,$,$,#2406,.F.);
+#2427=EDGE_LOOP($,(#2418,#2424,#2425,#2426));
+#2428=FACE_OUTER_BOUND('',#2427,.T.);
+#2429=ADVANCED_FACE('',(#2428),#2417,.T.);
+#2430=CARTESIAN_POINT($,(-55.245,31.75254,1.90746000000001));
+#2431=DIRECTION($,(-0,-1,-0));
+#2432=DIRECTION($,(-1,0,0));
+#2433=AXIS2_PLACEMENT_3D($,#2430,#2431,#2432);
+#2434=PLANE($,#2433);
+#2435=ORIENTED_EDGE($,$,$,#1058,.T.);
+#2436=CARTESIAN_POINT($,(-169.545,31.75254,1.90746000000001));
+#2437=DIRECTION($,(0,0,-1));
+#2438=VECTOR($,#2437,1);
+#2439=LINE($,#2436,#2438);
+#2440=EDGE_CURVE($,#1053,#1139,#2439,.T.);
+#2441=ORIENTED_EDGE($,$,$,#2440,.T.);
+#2442=ORIENTED_EDGE($,$,$,#1152,.T.);
+#2443=ORIENTED_EDGE($,$,$,#2423,.F.);
+#2444=EDGE_LOOP($,(#2435,#2441,#2442,#2443));
+#2445=FACE_OUTER_BOUND('',#2444,.T.);
+#2446=ADVANCED_FACE('',(#2445),#2434,.T.);
+#2447=CARTESIAN_POINT($,(-169.545,31.75254,1.90746000000001));
+#2448=DIRECTION($,(0.707106781186548,-0.707106781186547,0));
+#2449=DIRECTION($,(-0.707106781186547,-0.707106781186548,0));
+#2450=AXIS2_PLACEMENT_3D($,#2447,#2448,#2449);
+#2451=PLANE($,#2450);
+#2452=ORIENTED_EDGE($,$,$,#1066,.T.);
+#2453=CARTESIAN_POINT($,(-175.895,25.40254,1.90746000000001));
+#2454=DIRECTION($,(0,0,-1));
+#2455=VECTOR($,#2454,1);
+#2456=LINE($,#2453,#2455);
+#2457=EDGE_CURVE($,#1061,#1131,#2456,.T.);
+#2458=ORIENTED_EDGE($,$,$,#2457,.T.);
+#2459=ORIENTED_EDGE($,$,$,#1144,.T.);
+#2460=ORIENTED_EDGE($,$,$,#2440,.F.);
+#2461=EDGE_LOOP($,(#2452,#2458,#2459,#2460));
+#2462=FACE_OUTER_BOUND('',#2461,.T.);
+#2463=ADVANCED_FACE('',(#2462),#2451,.T.);
+#2464=CARTESIAN_POINT($,(-175.895,25.40254,1.90746000000001));
#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));
+#2466=DIRECTION($,(0,-1,0));
+#2467=AXIS2_PLACEMENT_3D($,#2464,#2465,#2466);
+#2468=PLANE($,#2467);
+#2469=ORIENTED_EDGE($,$,$,#1074,.T.);
+#2470=CARTESIAN_POINT($,(-175.895,0.002539999999996,1.90746000000001));
+#2471=DIRECTION($,(0,0,-1));
+#2472=VECTOR($,#2471,1);
+#2473=LINE($,#2470,#2472);
+#2474=EDGE_CURVE($,#1069,#1123,#2473,.T.);
+#2475=ORIENTED_EDGE($,$,$,#2474,.T.);
+#2476=ORIENTED_EDGE($,$,$,#1136,.T.);
+#2477=ORIENTED_EDGE($,$,$,#2457,.F.);
+#2478=EDGE_LOOP($,(#2469,#2475,#2476,#2477));
+#2479=FACE_OUTER_BOUND('',#2478,.T.);
+#2480=ADVANCED_FACE('',(#2479),#2468,.T.);
+#2481=CARTESIAN_POINT($,(-175.895,0.002539999999996,1.90746000000001));
+#2482=DIRECTION($,(-0,-1,-0));
+#2483=DIRECTION($,(-1,0,0));
+#2484=AXIS2_PLACEMENT_3D($,#2481,#2482,#2483);
+#2485=PLANE($,#2484);
+#2486=ORIENTED_EDGE($,$,$,#1082,.T.);
+#2487=CARTESIAN_POINT($,(-233.045,0.002539999999996,1.90746000000001));
+#2488=DIRECTION($,(0,0,-1));
+#2489=VECTOR($,#2488,1);
+#2490=LINE($,#2487,#2489);
+#2491=EDGE_CURVE($,#1077,#1121,#2490,.T.);
+#2492=ORIENTED_EDGE($,$,$,#2491,.T.);
+#2493=ORIENTED_EDGE($,$,$,#1128,.T.);
+#2494=ORIENTED_EDGE($,$,$,#2474,.F.);
+#2495=EDGE_LOOP($,(#2486,#2492,#2493,#2494));
+#2496=FACE_OUTER_BOUND('',#2495,.T.);
+#2497=ADVANCED_FACE('',(#2496),#2485,.T.);
+#2498=CARTESIAN_POINT($,(-233.045,0.002539999999996,1.90746000000001));
+#2499=DIRECTION($,(-1,0,0));
+#2500=DIRECTION($,(0,1,0));
+#2501=AXIS2_PLACEMENT_3D($,#2498,#2499,#2500);
+#2502=PLANE($,#2501);
+#2503=ORIENTED_EDGE($,$,$,#1088,.T.);
+#2504=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#2505=DIRECTION($,(0,0,-1));
+#2506=VECTOR($,#2505,1);
+#2507=LINE($,#2504,#2506);
+#2508=EDGE_CURVE($,#1011,#1187,#2507,.T.);
+#2509=ORIENTED_EDGE($,$,$,#2508,.T.);
+#2510=ORIENTED_EDGE($,$,$,#1198,.T.);
+#2511=ORIENTED_EDGE($,$,$,#2491,.F.);
+#2512=EDGE_LOOP($,(#2503,#2509,#2510,#2511));
+#2513=FACE_OUTER_BOUND('',#2512,.T.);
+#2514=ADVANCED_FACE('',(#2513),#2502,.T.);
+#2515=CARTESIAN_POINT($,(-8.255,49.83226,8.25746000000001));
+#2516=DIRECTION($,(1,-0,0));
+#2517=DIRECTION($,(0,-0.707106781186547,-0.707106781186548));
+#2518=AXIS2_PLACEMENT_3D($,#2515,#2516,#2517);
+#2519=PLANE($,#2518);
+#2520=ORIENTED_EDGE($,$,$,#1237,.T.);
+#2521=ORIENTED_EDGE($,$,$,#2374,.F.);
+#2522=ORIENTED_EDGE($,$,$,#1263,.T.);
+#2523=ORIENTED_EDGE($,$,$,#2071,.F.);
+#2524=EDGE_LOOP($,(#2520,#2521,#2522,#2523));
+#2525=FACE_OUTER_BOUND('',#2524,.T.);
+#2526=ADVANCED_FACE('',(#2525),#2519,.T.);
+#2527=CARTESIAN_POINT($,(-233.045,43.48226,1.90746000000001));
+#2528=DIRECTION($,(-1,0,0));
+#2529=DIRECTION($,(0,0.707106781186547,0.707106781186548));
+#2530=AXIS2_PLACEMENT_3D($,#2527,#2528,#2529);
+#2531=PLANE($,#2530);
+#2532=ORIENTED_EDGE($,$,$,#1246,.T.);
+#2533=ORIENTED_EDGE($,$,$,#2100,.F.);
+#2534=ORIENTED_EDGE($,$,$,#1272,.T.);
+#2535=ORIENTED_EDGE($,$,$,#2508,.F.);
+#2536=EDGE_LOOP($,(#2532,#2533,#2534,#2535));
+#2537=FACE_OUTER_BOUND('',#2536,.T.);
+#2538=ADVANCED_FACE('',(#2537),#2531,.T.);
+#2539=CARTESIAN_POINT($,(-233.045,440.99226,1.90746000000001));
+#2540=DIRECTION($,(-1,0,0));
+#2541=DIRECTION($,(0,1,0));
+#2542=AXIS2_PLACEMENT_3D($,#2539,#2540,#2541);
+#2543=PLANE($,#2542);
+#2544=ORIENTED_EDGE($,$,$,#1298,.T.);
+#2545=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#2546=DIRECTION($,(0,0,-1));
+#2547=VECTOR($,#2546,1);
+#2548=LINE($,#2545,#2547);
+#2549=EDGE_CURVE($,#1293,#1475,#2548,.T.);
+#2550=ORIENTED_EDGE($,$,$,#2549,.T.);
+#2551=ORIENTED_EDGE($,$,$,#1488,.T.);
+#2552=CARTESIAN_POINT($,(-233.045,440.99226,0.00246000000001));
+#2553=DIRECTION($,(0,0,1));
+#2554=VECTOR($,#2553,1);
+#2555=LINE($,#2552,#2554);
+#2556=EDGE_CURVE($,#1483,#1285,#2555,.T.);
+#2557=ORIENTED_EDGE($,$,$,#2556,.T.);
+#2558=EDGE_LOOP($,(#2544,#2550,#2551,#2557));
+#2559=FACE_OUTER_BOUND('',#2558,.T.);
+#2560=ADVANCED_FACE('',(#2559),#2543,.T.);
+#2561=CARTESIAN_POINT($,(-233.045,485.44226,1.90746000000001));
+#2562=DIRECTION($,(-0,1,0));
+#2563=DIRECTION($,(1,0,0));
+#2564=AXIS2_PLACEMENT_3D($,#2561,#2562,#2563);
+#2565=PLANE($,#2564);
+#2566=ORIENTED_EDGE($,$,$,#1306,.T.);
+#2567=CARTESIAN_POINT($,(-198.755,485.44226,1.90746000000001));
+#2568=DIRECTION($,(0,0,-1));
+#2569=VECTOR($,#2568,1);
+#2570=LINE($,#2567,#2569);
+#2571=EDGE_CURVE($,#1301,#1467,#2570,.T.);
+#2572=ORIENTED_EDGE($,$,$,#2571,.T.);
+#2573=ORIENTED_EDGE($,$,$,#1480,.T.);
+#2574=ORIENTED_EDGE($,$,$,#2549,.F.);
+#2575=EDGE_LOOP($,(#2566,#2572,#2573,#2574));
+#2576=FACE_OUTER_BOUND('',#2575,.T.);
+#2577=ADVANCED_FACE('',(#2576),#2565,.T.);
+#2578=CARTESIAN_POINT($,(-198.755,485.44226,1.90746000000001));
+#2579=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#2580=DIRECTION($,(0.707106781186546,-0.707106781186549,0));
+#2581=AXIS2_PLACEMENT_3D($,#2578,#2579,#2580);
+#2582=PLANE($,#2581);
+#2583=ORIENTED_EDGE($,$,$,#1314,.T.);
+#2584=CARTESIAN_POINT($,(-192.405,479.09226,1.90746000000001));
+#2585=DIRECTION($,(0,0,-1));
+#2586=VECTOR($,#2585,1);
+#2587=LINE($,#2584,#2586);
+#2588=EDGE_CURVE($,#1309,#1459,#2587,.T.);
+#2589=ORIENTED_EDGE($,$,$,#2588,.T.);
+#2590=ORIENTED_EDGE($,$,$,#1472,.T.);
+#2591=ORIENTED_EDGE($,$,$,#2571,.F.);
+#2592=EDGE_LOOP($,(#2583,#2589,#2590,#2591));
+#2593=FACE_OUTER_BOUND('',#2592,.T.);
+#2594=ADVANCED_FACE('',(#2593),#2582,.T.);
+#2595=CARTESIAN_POINT($,(-192.405,479.09226,1.90746000000001));
+#2596=DIRECTION($,(1,0,0));
+#2597=DIRECTION($,(0,-1,0));
+#2598=AXIS2_PLACEMENT_3D($,#2595,#2596,#2597);
+#2599=PLANE($,#2598);
+#2600=ORIENTED_EDGE($,$,$,#1322,.T.);
+#2601=CARTESIAN_POINT($,(-192.405,460.04226,1.90746000000001));
+#2602=DIRECTION($,(0,0,-1));
+#2603=VECTOR($,#2602,1);
+#2604=LINE($,#2601,#2603);
+#2605=EDGE_CURVE($,#1317,#1451,#2604,.T.);
+#2606=ORIENTED_EDGE($,$,$,#2605,.T.);
+#2607=ORIENTED_EDGE($,$,$,#1464,.T.);
+#2608=ORIENTED_EDGE($,$,$,#2588,.F.);
+#2609=EDGE_LOOP($,(#2600,#2606,#2607,#2608));
+#2610=FACE_OUTER_BOUND('',#2609,.T.);
+#2611=ADVANCED_FACE('',(#2610),#2599,.T.);
+#2612=CARTESIAN_POINT($,(-192.405,460.04226,1.90746000000001));
+#2613=DIRECTION($,(0.707106781186549,0.707106781186546,0));
+#2614=DIRECTION($,(0.707106781186546,-0.707106781186549,0));
+#2615=AXIS2_PLACEMENT_3D($,#2612,#2613,#2614);
+#2616=PLANE($,#2615);
+#2617=ORIENTED_EDGE($,$,$,#1330,.T.);
+#2618=CARTESIAN_POINT($,(-186.055,453.69226,1.90746000000001));
+#2619=DIRECTION($,(0,0,-1));
+#2620=VECTOR($,#2619,1);
+#2621=LINE($,#2618,#2620);
+#2622=EDGE_CURVE($,#1325,#1443,#2621,.T.);
+#2623=ORIENTED_EDGE($,$,$,#2622,.T.);
+#2624=ORIENTED_EDGE($,$,$,#1456,.T.);
+#2625=ORIENTED_EDGE($,$,$,#2605,.F.);
+#2626=EDGE_LOOP($,(#2617,#2623,#2624,#2625));
+#2627=FACE_OUTER_BOUND('',#2626,.T.);
+#2628=ADVANCED_FACE('',(#2627),#2616,.T.);
+#2629=CARTESIAN_POINT($,(-186.055,453.69226,1.90746000000001));
+#2630=DIRECTION($,(-0,1,0));
+#2631=DIRECTION($,(1,0,0));
+#2632=AXIS2_PLACEMENT_3D($,#2629,#2630,#2631);
+#2633=PLANE($,#2632);
+#2634=ORIENTED_EDGE($,$,$,#1338,.T.);
+#2635=CARTESIAN_POINT($,(-71.755,453.69226,1.90746000000001));
+#2636=DIRECTION($,(0,0,-1));
+#2637=VECTOR($,#2636,1);
+#2638=LINE($,#2635,#2637);
+#2639=EDGE_CURVE($,#1333,#1435,#2638,.T.);
+#2640=ORIENTED_EDGE($,$,$,#2639,.T.);
+#2641=ORIENTED_EDGE($,$,$,#1448,.T.);
+#2642=ORIENTED_EDGE($,$,$,#2622,.F.);
+#2643=EDGE_LOOP($,(#2634,#2640,#2641,#2642));
+#2644=FACE_OUTER_BOUND('',#2643,.T.);
+#2645=ADVANCED_FACE('',(#2644),#2633,.T.);
+#2646=CARTESIAN_POINT($,(-71.755,453.69226,1.90746000000001));
+#2647=DIRECTION($,(-0.707106781186549,0.707106781186546,0));
+#2648=DIRECTION($,(0.707106781186546,0.707106781186549,0));
+#2649=AXIS2_PLACEMENT_3D($,#2646,#2647,#2648);
+#2650=PLANE($,#2649);
+#2651=ORIENTED_EDGE($,$,$,#1346,.T.);
+#2652=CARTESIAN_POINT($,(-65.405,460.04226,1.90746000000001));
+#2653=DIRECTION($,(0,0,-1));
+#2654=VECTOR($,#2653,1);
+#2655=LINE($,#2652,#2654);
+#2656=EDGE_CURVE($,#1341,#1427,#2655,.T.);
+#2657=ORIENTED_EDGE($,$,$,#2656,.T.);
+#2658=ORIENTED_EDGE($,$,$,#1440,.T.);
+#2659=ORIENTED_EDGE($,$,$,#2639,.F.);
+#2660=EDGE_LOOP($,(#2651,#2657,#2658,#2659));
+#2661=FACE_OUTER_BOUND('',#2660,.T.);
+#2662=ADVANCED_FACE('',(#2661),#2650,.T.);
+#2663=CARTESIAN_POINT($,(-65.405,460.04226,1.90746000000001));
+#2664=DIRECTION($,(-1,0,0));
+#2665=DIRECTION($,(0,1,0));
+#2666=AXIS2_PLACEMENT_3D($,#2663,#2664,#2665);
+#2667=PLANE($,#2666);
+#2668=ORIENTED_EDGE($,$,$,#1354,.T.);
+#2669=CARTESIAN_POINT($,(-65.405,479.09226,1.90746000000001));
+#2670=DIRECTION($,(0,0,-1));
+#2671=VECTOR($,#2670,1);
+#2672=LINE($,#2669,#2671);
+#2673=EDGE_CURVE($,#1349,#1419,#2672,.T.);
+#2674=ORIENTED_EDGE($,$,$,#2673,.T.);
+#2675=ORIENTED_EDGE($,$,$,#1432,.T.);
+#2676=ORIENTED_EDGE($,$,$,#2656,.F.);
+#2677=EDGE_LOOP($,(#2668,#2674,#2675,#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));
+#2679=ADVANCED_FACE('',(#2678),#2667,.T.);
+#2680=CARTESIAN_POINT($,(-65.405,479.09226,1.90746000000001));
+#2681=DIRECTION($,(-0.707106781186549,0.707106781186546,0));
+#2682=DIRECTION($,(0.707106781186546,0.707106781186549,0));
+#2683=AXIS2_PLACEMENT_3D($,#2680,#2681,#2682);
+#2684=PLANE($,#2683);
+#2685=ORIENTED_EDGE($,$,$,#1362,.T.);
+#2686=CARTESIAN_POINT($,(-59.055,485.44226,1.90746000000001));
+#2687=DIRECTION($,(0,0,-1));
+#2688=VECTOR($,#2687,1);
+#2689=LINE($,#2686,#2688);
+#2690=EDGE_CURVE($,#1357,#1411,#2689,.T.);
+#2691=ORIENTED_EDGE($,$,$,#2690,.T.);
+#2692=ORIENTED_EDGE($,$,$,#1424,.T.);
+#2693=ORIENTED_EDGE($,$,$,#2673,.F.);
+#2694=EDGE_LOOP($,(#2685,#2691,#2692,#2693));
+#2695=FACE_OUTER_BOUND('',#2694,.T.);
+#2696=ADVANCED_FACE('',(#2695),#2684,.T.);
+#2697=CARTESIAN_POINT($,(-59.055,485.44226,1.90746000000001));
+#2698=DIRECTION($,(-0,1,0));
+#2699=DIRECTION($,(1,0,0));
+#2700=AXIS2_PLACEMENT_3D($,#2697,#2698,#2699);
+#2701=PLANE($,#2700);
+#2702=ORIENTED_EDGE($,$,$,#1370,.T.);
+#2703=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#2704=DIRECTION($,(0,0,-1));
+#2705=VECTOR($,#2704,1);
+#2706=LINE($,#2703,#2705);
+#2707=EDGE_CURVE($,#1365,#1409,#2706,.T.);
+#2708=ORIENTED_EDGE($,$,$,#2707,.T.);
+#2709=ORIENTED_EDGE($,$,$,#1416,.T.);
+#2710=ORIENTED_EDGE($,$,$,#2690,.F.);
+#2711=EDGE_LOOP($,(#2702,#2708,#2709,#2710));
+#2712=FACE_OUTER_BOUND('',#2711,.T.);
+#2713=ADVANCED_FACE('',(#2712),#2701,.T.);
+#2714=CARTESIAN_POINT($,(-8.255,485.44226,1.90746000000001));
+#2715=DIRECTION($,(1,-0,0));
+#2716=DIRECTION($,(-0,-1,0));
+#2717=AXIS2_PLACEMENT_3D($,#2714,#2715,#2716);
+#2718=PLANE($,#2717);
+#2719=ORIENTED_EDGE($,$,$,#1376,.T.);
+#2720=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#2721=DIRECTION($,(0,0,-1));
+#2722=VECTOR($,#2721,1);
+#2723=LINE($,#2720,#2722);
+#2724=EDGE_CURVE($,#1283,#1491,#2723,.T.);
+#2725=ORIENTED_EDGE($,$,$,#2724,.T.);
+#2726=ORIENTED_EDGE($,$,$,#1502,.T.);
+#2727=ORIENTED_EDGE($,$,$,#2707,.F.);
+#2728=EDGE_LOOP($,(#2719,#2725,#2726,#2727));
+#2729=FACE_OUTER_BOUND('',#2728,.T.);
+#2730=ADVANCED_FACE('',(#2729),#2718,.T.);
+#2731=CARTESIAN_POINT($,(-233.045,434.64226,8.25746000000001));
+#2732=DIRECTION($,(-1,-0,-0));
+#2733=DIRECTION($,(0,0.707106781186549,-0.707106781186546));
#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));
+#2735=PLANE($,#2734);
+#2736=ORIENTED_EDGE($,$,$,#1541,.T.);
+#2737=ORIENTED_EDGE($,$,$,#2556,.F.);
+#2738=ORIENTED_EDGE($,$,$,#1567,.T.);
+#2739=ORIENTED_EDGE($,$,$,#2139,.F.);
+#2740=EDGE_LOOP($,(#2736,#2737,#2738,#2739));
+#2741=FACE_OUTER_BOUND('',#2740,.T.);
+#2742=ADVANCED_FACE('',(#2741),#2735,.T.);
+#2743=CARTESIAN_POINT($,(-8.255,440.99226,1.90746000000001));
+#2744=DIRECTION($,(1,0,0));
+#2745=DIRECTION($,(0,-0.707106781186549,0.707106781186546));
#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));
+#2747=PLANE($,#2746);
+#2748=ORIENTED_EDGE($,$,$,#1550,.T.);
+#2749=ORIENTED_EDGE($,$,$,#2168,.F.);
+#2750=ORIENTED_EDGE($,$,$,#1576,.T.);
+#2751=ORIENTED_EDGE($,$,$,#2724,.F.);
+#2752=EDGE_LOOP($,(#2748,#2749,#2750,#2751));
+#2753=FACE_OUTER_BOUND('',#2752,.T.);
+#2754=ADVANCED_FACE('',(#2753),#2747,.T.);
+#2755=CARTESIAN_POINT($,(8.76783352130505,308.12486,119.403106478695));
+#2756=DIRECTION($,(-0,1,0));
+#2757=DIRECTION($,(0.707106781186548,0,0.707106781186548));
#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);
+#2759=PLANE($,#2758);
+#2760=ORIENTED_EDGE($,$,$,#1602,.T.);
+#2761=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#2762=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2763=VECTOR($,#2762,1);
+#2764=LINE($,#2761,#2763);
+#2765=EDGE_CURVE($,#1597,#1748,#2764,.T.);
+#2766=ORIENTED_EDGE($,$,$,#2765,.T.);
+#2767=ORIENTED_EDGE($,$,$,#1761,.T.);
+#2768=CARTESIAN_POINT($,(10.1148719394654,308.12486,118.056068060535));
+#2769=DIRECTION($,(-0.707106781186549,0,0.707106781186546));
+#2770=VECTOR($,#2769,1);
+#2771=LINE($,#2768,#2770);
+#2772=EDGE_CURVE($,#1756,#1589,#2771,.T.);
+#2773=ORIENTED_EDGE($,$,$,#2772,.T.);
+#2774=EDGE_LOOP($,(#2760,#2766,#2767,#2773));
+#2775=FACE_OUTER_BOUND('',#2774,.T.);
+#2776=ADVANCED_FACE('',(#2775),#2759,.T.);
+#2777=CARTESIAN_POINT($,(43.0724119037892,308.12486,153.707684861179));
+#2778=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2779=DIRECTION($,(0,-1,0));
+#2780=AXIS2_PLACEMENT_3D($,#2777,#2778,#2779);
+#2781=PLANE($,#2780);
+#2782=ORIENTED_EDGE($,$,$,#1610,.T.);
+#2783=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#2784=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2785=VECTOR($,#2784,1);
+#2786=LINE($,#2783,#2785);
+#2787=EDGE_CURVE($,#1605,#1740,#2786,.T.);
+#2788=ORIENTED_EDGE($,$,$,#2787,.T.);
+#2789=ORIENTED_EDGE($,$,$,#1753,.T.);
+#2790=ORIENTED_EDGE($,$,$,#2765,.F.);
+#2791=EDGE_LOOP($,(#2782,#2788,#2789,#2790));
+#2792=FACE_OUTER_BOUND('',#2791,.T.);
+#2793=ADVANCED_FACE('',(#2792),#2781,.T.);
+#2794=CARTESIAN_POINT($,(43.0724119037892,295.42486,153.707684861179));
+#2795=DIRECTION($,(-0,1,0));
+#2796=DIRECTION($,(0.707106781186548,0,0.707106781186547));
+#2797=AXIS2_PLACEMENT_3D($,#2794,#2795,#2796);
+#2798=PLANE($,#2797);
+#2799=ORIENTED_EDGE($,$,$,#1618,.T.);
+#2800=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#2801=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2802=VECTOR($,#2801,1);
+#2803=LINE($,#2800,#2802);
+#2804=EDGE_CURVE($,#1613,#1732,#2803,.T.);
+#2805=ORIENTED_EDGE($,$,$,#2804,.T.);
+#2806=ORIENTED_EDGE($,$,$,#1745,.T.);
+#2807=ORIENTED_EDGE($,$,$,#2787,.F.);
+#2808=EDGE_LOOP($,(#2799,#2805,#2806,#2807));
+#2809=FACE_OUTER_BOUND('',#2808,.T.);
+#2810=ADVANCED_FACE('',(#2809),#2798,.T.);
+#2811=CARTESIAN_POINT($,(52.0526680248584,295.42486,162.687940982248));
+#2812=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2813=DIRECTION($,(0,-1,0));
+#2814=AXIS2_PLACEMENT_3D($,#2811,#2812,#2813);
+#2815=PLANE($,#2814);
+#2816=ORIENTED_EDGE($,$,$,#1626,.T.);
+#2817=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#2818=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2819=VECTOR($,#2818,1);
+#2820=LINE($,#2817,#2819);
+#2821=EDGE_CURVE($,#1621,#1724,#2820,.T.);
+#2822=ORIENTED_EDGE($,$,$,#2821,.T.);
+#2823=ORIENTED_EDGE($,$,$,#1737,.T.);
+#2824=ORIENTED_EDGE($,$,$,#2804,.F.);
+#2825=EDGE_LOOP($,(#2816,#2822,#2823,#2824));
+#2826=FACE_OUTER_BOUND('',#2825,.T.);
+#2827=ADVANCED_FACE('',(#2826),#2815,.T.);
+#2828=CARTESIAN_POINT($,(52.0526680248584,193.82486,162.687940982248));
+#2829=DIRECTION($,(0,-1,-0));
+#2830=DIRECTION($,(-0.707106781186548,0,-0.707106781186547));
+#2831=AXIS2_PLACEMENT_3D($,#2828,#2829,#2830);
+#2832=PLANE($,#2831);
+#2833=ORIENTED_EDGE($,$,$,#1634,.T.);
+#2834=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#2835=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2836=VECTOR($,#2835,1);
+#2837=LINE($,#2834,#2836);
+#2838=EDGE_CURVE($,#1629,#1716,#2837,.T.);
+#2839=ORIENTED_EDGE($,$,$,#2838,.T.);
+#2840=ORIENTED_EDGE($,$,$,#1729,.T.);
+#2841=ORIENTED_EDGE($,$,$,#2821,.F.);
+#2842=EDGE_LOOP($,(#2833,#2839,#2840,#2841));
+#2843=FACE_OUTER_BOUND('',#2842,.T.);
+#2844=ADVANCED_FACE('',(#2843),#2832,.T.);
+#2845=CARTESIAN_POINT($,(43.0724119037892,193.82486,153.707684861179));
+#2846=DIRECTION($,(0.707106781186548,0,0.707106781186548));
+#2847=DIRECTION($,(0,-1,0));
+#2848=AXIS2_PLACEMENT_3D($,#2845,#2846,#2847);
+#2849=PLANE($,#2848);
+#2850=ORIENTED_EDGE($,$,$,#1642,.T.);
+#2851=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#2852=DIRECTION($,(0.707106781186548,0,-0.707106781186548));
+#2853=VECTOR($,#2852,1);
+#2854=LINE($,#2851,#2853);
+#2855=EDGE_CURVE($,#1637,#1714,#2854,.T.);
+#2856=ORIENTED_EDGE($,$,$,#2855,.T.);
+#2857=ORIENTED_EDGE($,$,$,#1721,.T.);
+#2858=ORIENTED_EDGE($,$,$,#2838,.F.);
+#2859=EDGE_LOOP($,(#2850,#2856,#2857,#2858));
+#2860=FACE_OUTER_BOUND('',#2859,.T.);
+#2861=ADVANCED_FACE('',(#2860),#2849,.T.);
+#2862=CARTESIAN_POINT($,(43.0724119037892,181.12486,153.707684861179));
+#2863=DIRECTION($,(0,-1,-0));
+#2864=DIRECTION($,(-0.707106781186548,0,-0.707106781186548));
+#2865=AXIS2_PLACEMENT_3D($,#2862,#2863,#2864);
+#2866=PLANE($,#2865);
+#2867=ORIENTED_EDGE($,$,$,#1648,.T.);
+#2868=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#2869=DIRECTION($,(0.707106781186549,0,-0.707106781186546));
+#2870=VECTOR($,#2869,1);
+#2871=LINE($,#2868,#2870);
+#2872=EDGE_CURVE($,#1587,#1764,#2871,.T.);
+#2873=ORIENTED_EDGE($,$,$,#2872,.T.);
+#2874=ORIENTED_EDGE($,$,$,#1775,.T.);
+#2875=ORIENTED_EDGE($,$,$,#2855,.F.);
+#2876=EDGE_LOOP($,(#2867,#2873,#2874,#2875));
+#2877=FACE_OUTER_BOUND('',#2876,.T.);
+#2878=ADVANCED_FACE('',(#2877),#2866,.T.);
+#2879=CARTESIAN_POINT($,(6.35,181.12486,113.56594));
+#2880=DIRECTION($,(0,0,-1));
+#2881=DIRECTION($,(0,1,0));
+#2882=AXIS2_PLACEMENT_3D($,#2879,#2880,#2881);
+#2883=PLANE($,#2882);
+#2884=ORIENTED_EDGE($,$,$,#1848,.T.);
+#2885=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#2886=DIRECTION($,(1,0,0));
+#2887=VECTOR($,#2886,1);
+#2888=LINE($,#2885,#2887);
+#2889=EDGE_CURVE($,#1843,#1877,#2888,.T.);
+#2890=ORIENTED_EDGE($,$,$,#2889,.T.);
+#2891=ORIENTED_EDGE($,$,$,#1892,.T.);
+#2892=CARTESIAN_POINT($,(8.255,181.12486,113.56594));
+#2893=DIRECTION($,(-1,0,0));
+#2894=VECTOR($,#2893,1);
+#2895=LINE($,#2892,#2894);
+#2896=EDGE_CURVE($,#1887,#1841,#2895,.T.);
+#2897=ORIENTED_EDGE($,$,$,#2896,.T.);
+#2898=EDGE_LOOP($,(#2884,#2890,#2891,#2897));
+#2899=FACE_OUTER_BOUND('',#2898,.T.);
+#2900=ADVANCED_FACE('',(#2899),#2883,.T.);
+#2901=CARTESIAN_POINT($,(6.35,308.12486,113.56594));
+#2902=DIRECTION($,(0,1,0));
+#2903=DIRECTION($,(0.382683432365089,0,0.923879532511287));
+#2904=AXIS2_PLACEMENT_3D($,#2901,#2902,#2903);
+#2905=PLANE($,#2904);
+#2906=ORIENTED_EDGE($,$,$,#1856,.T.);
+#2907=ORIENTED_EDGE($,$,$,#2772,.F.);
+#2908=ORIENTED_EDGE($,$,$,#1884,.T.);
+#2909=ORIENTED_EDGE($,$,$,#2889,.F.);
+#2910=EDGE_LOOP($,(#2906,#2907,#2908,#2909));
+#2911=FACE_OUTER_BOUND('',#2910,.T.);
+#2912=ADVANCED_FACE('',(#2911),#2905,.T.);
+#2913=CARTESIAN_POINT($,(8.76783352130505,181.12486,119.403106478695));
+#2914=DIRECTION($,(0,-1,-0));
+#2915=DIRECTION($,(-0.382683432365089,0,-0.923879532511287));
+#2916=AXIS2_PLACEMENT_3D($,#2913,#2914,#2915);
+#2917=PLANE($,#2916);
+#2918=ORIENTED_EDGE($,$,$,#1865,.T.);
+#2919=ORIENTED_EDGE($,$,$,#2896,.F.);
+#2920=ORIENTED_EDGE($,$,$,#1900,.T.);
+#2921=ORIENTED_EDGE($,$,$,#2872,.F.);
+#2922=EDGE_LOOP($,(#2918,#2919,#2920,#2921));
+#2923=FACE_OUTER_BOUND('',#2922,.T.);
+#2924=ADVANCED_FACE('',(#2923),#2917,.T.);
+#2925=CARTESIAN_POINT($,(-38.1,96.774,76.2));
+#2926=DIRECTION($,(0,0,1));
+#2927=DIRECTION($,(1,0,0));
+#2928=AXIS2_PLACEMENT_3D($,#2925,#2926,#2927);
+#2929=CYLINDRICAL_SURFACE($,#2928,7.9375);
+#2930=ORIENTED_EDGE($,$,$,#111,.T.);
+#2931=EDGE_LOOP($,(#2930));
+#2932=FACE_OUTER_BOUND('',#2931,.T.);
+#2933=ORIENTED_EDGE($,$,$,#349,.T.);
+#2934=EDGE_LOOP($,(#2933));
+#2935=FACE_BOUND('',#2934,.T.);
+#2936=ADVANCED_FACE('',(#2932,#2935),#2929,.F.);
+#2937=CARTESIAN_POINT($,(-38.1,141.224,76.2));
+#2938=DIRECTION($,(0,0,1));
+#2939=DIRECTION($,(1,0,0));
+#2940=AXIS2_PLACEMENT_3D($,#2937,#2938,#2939);
+#2941=CYLINDRICAL_SURFACE($,#2940,7.9375);
+#2942=ORIENTED_EDGE($,$,$,#122,.T.);
+#2943=EDGE_LOOP($,(#2942));
+#2944=FACE_OUTER_BOUND('',#2943,.T.);
+#2945=ORIENTED_EDGE($,$,$,#360,.T.);
+#2946=EDGE_LOOP($,(#2945));
+#2947=FACE_BOUND('',#2946,.T.);
+#2948=ADVANCED_FACE('',(#2944,#2947),#2941,.F.);
+#2949=CARTESIAN_POINT($,(-38.1,185.674,76.2));
+#2950=DIRECTION($,(0,0,1));
+#2951=DIRECTION($,(1,0,0));
+#2952=AXIS2_PLACEMENT_3D($,#2949,#2950,#2951);
+#2953=CYLINDRICAL_SURFACE($,#2952,7.9375);
+#2954=ORIENTED_EDGE($,$,$,#133,.T.);
+#2955=EDGE_LOOP($,(#2954));
+#2956=FACE_OUTER_BOUND('',#2955,.T.);
+#2957=ORIENTED_EDGE($,$,$,#371,.T.);
+#2958=EDGE_LOOP($,(#2957));
+#2959=FACE_BOUND('',#2958,.T.);
+#2960=ADVANCED_FACE('',(#2956,#2959),#2953,.F.);
+#2961=CARTESIAN_POINT($,(-38.1,230.124,76.2));
+#2962=DIRECTION($,(0,0,1));
+#2963=DIRECTION($,(1,0,0));
+#2964=AXIS2_PLACEMENT_3D($,#2961,#2962,#2963);
+#2965=CYLINDRICAL_SURFACE($,#2964,7.9375);
+#2966=ORIENTED_EDGE($,$,$,#144,.T.);
+#2967=EDGE_LOOP($,(#2966));
+#2968=FACE_OUTER_BOUND('',#2967,.T.);
+#2969=ORIENTED_EDGE($,$,$,#382,.T.);
+#2970=EDGE_LOOP($,(#2969));
+#2971=FACE_BOUND('',#2970,.T.);
+#2972=ADVANCED_FACE('',(#2968,#2971),#2965,.F.);
+#2973=CARTESIAN_POINT($,(-151.9174,356.9208,76.2));
+#2974=DIRECTION($,(0,0,1));
+#2975=DIRECTION($,(1,0,0));
+#2976=AXIS2_PLACEMENT_3D($,#2973,#2974,#2975);
+#2977=CYLINDRICAL_SURFACE($,#2976,25.4);
+#2978=ORIENTED_EDGE($,$,$,#155,.T.);
+#2979=EDGE_LOOP($,(#2978));
+#2980=FACE_OUTER_BOUND('',#2979,.T.);
+#2981=ORIENTED_EDGE($,$,$,#393,.T.);
+#2982=EDGE_LOOP($,(#2981));
+#2983=FACE_BOUND('',#2982,.T.);
+#2984=ADVANCED_FACE('',(#2980,#2983),#2977,.F.);
+#2985=CARTESIAN_POINT($,(-63.0174,331.5208,76.2));
+#2986=DIRECTION($,(0,0,1));
+#2987=DIRECTION($,(1,0,0));
+#2988=AXIS2_PLACEMENT_3D($,#2985,#2986,#2987);
+#2989=CYLINDRICAL_SURFACE($,#2988,19.05);
+#2990=ORIENTED_EDGE($,$,$,#166,.T.);
+#2991=EDGE_LOOP($,(#2990));
+#2992=FACE_OUTER_BOUND('',#2991,.T.);
+#2993=ORIENTED_EDGE($,$,$,#404,.T.);
+#2994=EDGE_LOOP($,(#2993));
+#2995=FACE_BOUND('',#2994,.T.);
+#2996=ADVANCED_FACE('',(#2992,#2995),#2989,.F.);
+#2997=CARTESIAN_POINT($,(-199.5424,122.0724,78.105));
+#2998=DIRECTION($,(-0,1,0));
+#2999=DIRECTION($,(1,0,0));
+#3000=AXIS2_PLACEMENT_3D($,#2997,#2998,#2999);
+#3001=PLANE($,#3000);
+#3002=ORIENTED_EDGE($,$,$,#194,.T.);
+#3003=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#3004=DIRECTION($,(0,0,-1));
+#3005=VECTOR($,#3004,1);
+#3006=LINE($,#3003,#3005);
+#3007=EDGE_CURVE($,#181,#411,#3006,.T.);
+#3008=ORIENTED_EDGE($,$,$,#3007,.T.);
+#3009=ORIENTED_EDGE($,$,$,#416,.F.);
+#3010=CARTESIAN_POINT($,(-199.5424,122.0724,76.2));
+#3011=DIRECTION($,(0,0,1));
+#3012=VECTOR($,#3011,1);
+#3013=LINE($,#3010,#3012);
+#3014=EDGE_CURVE($,#409,#189,#3013,.T.);
+#3015=ORIENTED_EDGE($,$,$,#3014,.T.);
+#3016=EDGE_LOOP($,(#3002,#3008,#3009,#3015));
+#3017=FACE_OUTER_BOUND('',#3016,.T.);
+#3018=ADVANCED_FACE('',(#3017),#3001,.T.);
+#3019=CARTESIAN_POINT($,(-180.4924,122.0724,78.105));
+#3020=DIRECTION($,(-1,0,0));
+#3021=DIRECTION($,(0,1,0));
+#3022=AXIS2_PLACEMENT_3D($,#3019,#3020,#3021);
+#3023=PLANE($,#3022);
+#3024=ORIENTED_EDGE($,$,$,#186,.T.);
+#3025=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#3026=DIRECTION($,(0,0,-1));
+#3027=VECTOR($,#3026,1);
+#3028=LINE($,#3025,#3027);
+#3029=EDGE_CURVE($,#171,#419,#3028,.T.);
+#3030=ORIENTED_EDGE($,$,$,#3029,.T.);
+#3031=ORIENTED_EDGE($,$,$,#424,.F.);
+#3032=ORIENTED_EDGE($,$,$,#3007,.F.);
+#3033=EDGE_LOOP($,(#3024,#3030,#3031,#3032));
+#3034=FACE_OUTER_BOUND('',#3033,.T.);
+#3035=ADVANCED_FACE('',(#3034),#3023,.T.);
+#3036=CARTESIAN_POINT($,(-180.4924,210.9724,78.105));
+#3037=DIRECTION($,(-0,-1,-0));
+#3038=DIRECTION($,(-1,0,0));
+#3039=AXIS2_PLACEMENT_3D($,#3036,#3037,#3038);
+#3040=PLANE($,#3039);
+#3041=ORIENTED_EDGE($,$,$,#178,.T.);
+#3042=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#3043=DIRECTION($,(0,0,-1));
+#3044=VECTOR($,#3043,1);
+#3045=LINE($,#3042,#3044);
+#3046=EDGE_CURVE($,#173,#427,#3045,.T.);
+#3047=ORIENTED_EDGE($,$,$,#3046,.T.);
+#3048=ORIENTED_EDGE($,$,$,#432,.F.);
+#3049=ORIENTED_EDGE($,$,$,#3029,.F.);
+#3050=EDGE_LOOP($,(#3041,#3047,#3048,#3049));
+#3051=FACE_OUTER_BOUND('',#3050,.T.);
+#3052=ADVANCED_FACE('',(#3051),#3040,.T.);
+#3053=CARTESIAN_POINT($,(-199.5424,210.9724,78.105));
+#3054=DIRECTION($,(1,0,0));
+#3055=DIRECTION($,(0,-1,0));
+#3056=AXIS2_PLACEMENT_3D($,#3053,#3054,#3055);
+#3057=PLANE($,#3056);
+#3058=ORIENTED_EDGE($,$,$,#200,.T.);
+#3059=ORIENTED_EDGE($,$,$,#3014,.F.);
+#3060=ORIENTED_EDGE($,$,$,#438,.F.);
+#3061=ORIENTED_EDGE($,$,$,#3046,.F.);
+#3062=EDGE_LOOP($,(#3058,#3059,#3060,#3061));
+#3063=FACE_OUTER_BOUND('',#3062,.T.);
+#3064=ADVANCED_FACE('',(#3063),#3057,.T.);
+#3065=CARTESIAN_POINT($,(-136.0424,122.0724,78.105));
+#3066=DIRECTION($,(-0,1,0));
+#3067=DIRECTION($,(1,0,0));
+#3068=AXIS2_PLACEMENT_3D($,#3065,#3066,#3067);
+#3069=PLANE($,#3068);
+#3070=ORIENTED_EDGE($,$,$,#228,.T.);
+#3071=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#3072=DIRECTION($,(0,0,-1));
+#3073=VECTOR($,#3072,1);
+#3074=LINE($,#3071,#3073);
+#3075=EDGE_CURVE($,#215,#445,#3074,.T.);
+#3076=ORIENTED_EDGE($,$,$,#3075,.T.);
+#3077=ORIENTED_EDGE($,$,$,#450,.F.);
+#3078=CARTESIAN_POINT($,(-136.0424,122.0724,76.2));
+#3079=DIRECTION($,(0,0,1));
+#3080=VECTOR($,#3079,1);
+#3081=LINE($,#3078,#3080);
+#3082=EDGE_CURVE($,#443,#223,#3081,.T.);
+#3083=ORIENTED_EDGE($,$,$,#3082,.T.);
+#3084=EDGE_LOOP($,(#3070,#3076,#3077,#3083));
+#3085=FACE_OUTER_BOUND('',#3084,.T.);
+#3086=ADVANCED_FACE('',(#3085),#3069,.T.);
+#3087=CARTESIAN_POINT($,(-116.9924,122.0724,78.105));
+#3088=DIRECTION($,(-1,0,0));
+#3089=DIRECTION($,(0,1,0));
+#3090=AXIS2_PLACEMENT_3D($,#3087,#3088,#3089);
+#3091=PLANE($,#3090);
+#3092=ORIENTED_EDGE($,$,$,#220,.T.);
+#3093=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#3094=DIRECTION($,(0,0,-1));
+#3095=VECTOR($,#3094,1);
+#3096=LINE($,#3093,#3095);
+#3097=EDGE_CURVE($,#205,#453,#3096,.T.);
+#3098=ORIENTED_EDGE($,$,$,#3097,.T.);
+#3099=ORIENTED_EDGE($,$,$,#458,.F.);
+#3100=ORIENTED_EDGE($,$,$,#3075,.F.);
+#3101=EDGE_LOOP($,(#3092,#3098,#3099,#3100));
+#3102=FACE_OUTER_BOUND('',#3101,.T.);
+#3103=ADVANCED_FACE('',(#3102),#3091,.T.);
+#3104=CARTESIAN_POINT($,(-116.9924,210.9724,78.105));
+#3105=DIRECTION($,(-0,-1,-0));
+#3106=DIRECTION($,(-1,0,0));
+#3107=AXIS2_PLACEMENT_3D($,#3104,#3105,#3106);
+#3108=PLANE($,#3107);
+#3109=ORIENTED_EDGE($,$,$,#212,.T.);
+#3110=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#3111=DIRECTION($,(0,0,-1));
+#3112=VECTOR($,#3111,1);
+#3113=LINE($,#3110,#3112);
+#3114=EDGE_CURVE($,#207,#461,#3113,.T.);
+#3115=ORIENTED_EDGE($,$,$,#3114,.T.);
+#3116=ORIENTED_EDGE($,$,$,#466,.F.);
+#3117=ORIENTED_EDGE($,$,$,#3097,.F.);
+#3118=EDGE_LOOP($,(#3109,#3115,#3116,#3117));
+#3119=FACE_OUTER_BOUND('',#3118,.T.);
+#3120=ADVANCED_FACE('',(#3119),#3108,.T.);
+#3121=CARTESIAN_POINT($,(-136.0424,210.9724,78.105));
+#3122=DIRECTION($,(1,0,0));
+#3123=DIRECTION($,(0,-1,0));
+#3124=AXIS2_PLACEMENT_3D($,#3121,#3122,#3123);
+#3125=PLANE($,#3124);
+#3126=ORIENTED_EDGE($,$,$,#234,.T.);
+#3127=ORIENTED_EDGE($,$,$,#3082,.F.);
+#3128=ORIENTED_EDGE($,$,$,#472,.F.);
+#3129=ORIENTED_EDGE($,$,$,#3114,.F.);
+#3130=EDGE_LOOP($,(#3126,#3127,#3128,#3129));
+#3131=FACE_OUTER_BOUND('',#3130,.T.);
+#3132=ADVANCED_FACE('',(#3131),#3125,.T.);
+#3133=CARTESIAN_POINT($,(-19.05,466.3948,0.00246000000001));
+#3134=DIRECTION($,(0,0,1));
+#3135=DIRECTION($,(-1,0,0));
+#3136=AXIS2_PLACEMENT_3D($,#3133,#3134,#3135);
+#3137=CYLINDRICAL_SURFACE($,#3136,5.5626);
+#3138=ORIENTED_EDGE($,$,$,#1387,.T.);
+#3139=EDGE_LOOP($,(#3138));
+#3140=FACE_OUTER_BOUND('',#3139,.T.);
+#3141=ORIENTED_EDGE($,$,$,#1513,.T.);
+#3142=EDGE_LOOP($,(#3141));
+#3143=FACE_BOUND('',#3142,.T.);
+#3144=ADVANCED_FACE('',(#3140,#3143),#3137,.F.);
+#3145=CARTESIAN_POINT($,(-222.25,466.3948,0.00246000000001));
+#3146=DIRECTION($,(0,0,1));
+#3147=DIRECTION($,(-1,0,0));
+#3148=AXIS2_PLACEMENT_3D($,#3145,#3146,#3147);
+#3149=CYLINDRICAL_SURFACE($,#3148,5.5626);
+#3150=ORIENTED_EDGE($,$,$,#1398,.T.);
+#3151=EDGE_LOOP($,(#3150));
+#3152=FACE_OUTER_BOUND('',#3151,.T.);
+#3153=ORIENTED_EDGE($,$,$,#1524,.T.);
+#3154=EDGE_LOOP($,(#3153));
+#3155=FACE_BOUND('',#3154,.T.);
+#3156=ADVANCED_FACE('',(#3152,#3155),#3149,.F.);
+#3157=CARTESIAN_POINT($,(-222.25,19.05,0.00246000000001));
+#3158=DIRECTION($,(0,0,1));
+#3159=DIRECTION($,(1,0,0));
+#3160=AXIS2_PLACEMENT_3D($,#3157,#3158,#3159);
+#3161=CYLINDRICAL_SURFACE($,#3160,5.5626);
+#3162=ORIENTED_EDGE($,$,$,#1099,.T.);
+#3163=EDGE_LOOP($,(#3162));
+#3164=FACE_OUTER_BOUND('',#3163,.T.);
+#3165=ORIENTED_EDGE($,$,$,#1209,.T.);
+#3166=EDGE_LOOP($,(#3165));
+#3167=FACE_BOUND('',#3166,.T.);
+#3168=ADVANCED_FACE('',(#3164,#3167),#3161,.F.);
+#3169=CARTESIAN_POINT($,(-19.05,19.05,0.00246000000001));
+#3170=DIRECTION($,(0,0,1));
+#3171=DIRECTION($,(1,0,0));
+#3172=AXIS2_PLACEMENT_3D($,#3169,#3170,#3171);
+#3173=CYLINDRICAL_SURFACE($,#3172,5.5626);
+#3174=ORIENTED_EDGE($,$,$,#1110,.T.);
+#3175=EDGE_LOOP($,(#3174));
+#3176=FACE_OUTER_BOUND('',#3175,.T.);
+#3177=ORIENTED_EDGE($,$,$,#1220,.T.);
+#3178=EDGE_LOOP($,(#3177));
+#3179=FACE_BOUND('',#3178,.T.);
+#3180=ADVANCED_FACE('',(#3176,#3179),#3173,.F.);
+#3181=CARTESIAN_POINT($,(31.8483617530013,244.62486,139.789557874071));
+#3182=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#3183=DIRECTION($,(0,1,0));
+#3184=AXIS2_PLACEMENT_3D($,#3181,#3182,#3183);
+#3185=CYLINDRICAL_SURFACE($,#3184,13.5255);
+#3186=ORIENTED_EDGE($,$,$,#1659,.T.);
+#3187=EDGE_LOOP($,(#3186));
+#3188=FACE_OUTER_BOUND('',#3187,.T.);
+#3189=ORIENTED_EDGE($,$,$,#1786,.T.);
+#3190=EDGE_LOOP($,(#3189));
+#3191=FACE_BOUND('',#3190,.T.);
+#3192=ADVANCED_FACE('',(#3188,#3191),#3185,.F.);
+#3193=CARTESIAN_POINT($,(21.9700800198253,225.57486,129.911276140894));
+#3194=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#3195=DIRECTION($,(0,1,0));
+#3196=AXIS2_PLACEMENT_3D($,#3193,#3194,#3195);
+#3197=CYLINDRICAL_SURFACE($,#3196,2.38125);
+#3198=ORIENTED_EDGE($,$,$,#1670,.T.);
+#3199=EDGE_LOOP($,(#3198));
+#3200=FACE_OUTER_BOUND('',#3199,.T.);
+#3201=ORIENTED_EDGE($,$,$,#1797,.T.);
+#3202=EDGE_LOOP($,(#3201));
+#3203=FACE_BOUND('',#3202,.T.);
+#3204=ADVANCED_FACE('',(#3200,#3203),#3197,.F.);
+#3205=CARTESIAN_POINT($,(21.9700800198253,263.67486,129.911276140894));
+#3206=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#3207=DIRECTION($,(0,1,0));
+#3208=AXIS2_PLACEMENT_3D($,#3205,#3206,#3207);
+#3209=CYLINDRICAL_SURFACE($,#3208,2.38125);
+#3210=ORIENTED_EDGE($,$,$,#1681,.T.);
+#3211=EDGE_LOOP($,(#3210));
+#3212=FACE_OUTER_BOUND('',#3211,.T.);
+#3213=ORIENTED_EDGE($,$,$,#1808,.T.);
+#3214=EDGE_LOOP($,(#3213));
+#3215=FACE_BOUND('',#3214,.T.);
+#3216=ADVANCED_FACE('',(#3212,#3215),#3209,.F.);
+#3217=CARTESIAN_POINT($,(44.4207203224982,225.57486,152.361916443567));
+#3218=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#3219=DIRECTION($,(0,1,0));
+#3220=AXIS2_PLACEMENT_3D($,#3217,#3218,#3219);
+#3221=CYLINDRICAL_SURFACE($,#3220,2.38125);
+#3222=ORIENTED_EDGE($,$,$,#1692,.T.);
+#3223=EDGE_LOOP($,(#3222));
+#3224=FACE_OUTER_BOUND('',#3223,.T.);
+#3225=ORIENTED_EDGE($,$,$,#1819,.T.);
+#3226=EDGE_LOOP($,(#3225));
+#3227=FACE_BOUND('',#3226,.T.);
+#3228=ADVANCED_FACE('',(#3224,#3227),#3221,.F.);
+#3229=CARTESIAN_POINT($,(44.4207203224982,263.67486,152.361916443567));
+#3230=DIRECTION($,(-0.707106781186548,0,0.707106781186548));
+#3231=DIRECTION($,(0,1,0));
+#3232=AXIS2_PLACEMENT_3D($,#3229,#3230,#3231);
+#3233=CYLINDRICAL_SURFACE($,#3232,2.38125);
+#3234=ORIENTED_EDGE($,$,$,#1703,.T.);
+#3235=EDGE_LOOP($,(#3234));
+#3236=FACE_OUTER_BOUND('',#3235,.T.);
+#3237=ORIENTED_EDGE($,$,$,#1830,.T.);
+#3238=EDGE_LOOP($,(#3237));
+#3239=FACE_BOUND('',#3238,.T.);
+#3240=ADVANCED_FACE('',(#3236,#3239),#3233,.F.);
+#3241=CLOSED_SHELL($,(#238,#476,#516,#556,#582,#608,#648,#688,#714,#740,#780,#820,#846,#872,#912,#952,#978,#1004,#1114,#1224,#1250,#1276,#1402,#1528,#1554,#1580,#1707,#1834,#1869,#1904,#1926,#1948,#1965,#1987,#2004,#2026,#2043,#2060,#2082,#2104,#2116,#2128,#2150,#2172,#2184,#2196,#2218,#2235,#2252,#2264,#2276,#2298,#2315,#2332,#2344,#2356,#2378,#2395,#2412,#2429,#2446,#2463,#2480,#2497,#2514,#2526,#2538,#2560,#2577,#2594,#2611,#2628,#2645,#2662,#2679,#2696,#2713,#2730,#2742,#2754,#2776,#2793,#2810,#2827,#2844,#2861,#2878,#2900,#2912,#2924,#2936,#2948,#2960,#2972,#2984,#2996,#3018,#3035,#3052,#3064,#3086,#3103,#3120,#3132,#3144,#3156,#3168,#3180,#3192,#3204,#3216,#3228,#3240));
+#3242=MANIFOLD_SOLID_BREP('AetherisBody',#3241);
+#3243=APPLICATION_CONTEXT('mechanical design');
+#3244=PRODUCT_CONTEXT('',#3243,'mechanical');
+#3245=PRODUCT('AETHERIS','AetherisBody','',(#3244));
+#3246=PRODUCT_DEFINITION_FORMATION('','',#3245);
+#3247=PRODUCT_DEFINITION_CONTEXT('design',#3243,'design');
+#3248=PRODUCT_DEFINITION('','',#3246,#3247);
+#3249=PRODUCT_DEFINITION_SHAPE('','',#3248);
+#3250=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
+#3251=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
+#3252=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
+#3253=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#3250,#3251,#3252))REPRESENTATION_CONTEXT('3','3D'));
+#3254=SHAPE_REPRESENTATION('AetherisBody',(#3242),#3253);
+#3255=SHAPE_DEFINITION_REPRESENTATION(#3249,#3254);
ENDSEC;
END-ISO-10303-21;
diff --git a/docs/modules/sheetmetal/artifacts/m8/validation-report.md b/docs/modules/sheetmetal/artifacts/m8/validation-report.md
index 31cefae5..cc5457da 100644
--- a/docs/modules/sheetmetal/artifacts/m8/validation-report.md
+++ b/docs/modules/sheetmetal/artifacts/m8/validation-report.md
@@ -1,11 +1,11 @@
-# M8 validation report
+# M8/Profile-M2 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.
+- `dotnet test Aetheris.SheetMetal.Tests --no-restore`: pass, 60/60 in the full run; new Profile-M2 tests also pass after rebuild.
+- Full solution test execution completed. All feature suites passed; Kernel.Core exposed timing-test nondeterminism under parallel load. The two failures from the parallel run passed immediately in isolation; a later full Kernel.Core run exposed a different timing assertion, which also passed in isolation. `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.
@@ -13,16 +13,16 @@
## 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.
+Final authored recognition is `Complete`: 15 regions, seven bends, 17 cuts, nine patterns, three datums, one tab, two stepped-notch edge fragments, and 18 resolved constraints. Exact flat status is `Valid`; DFM is `Pass` after the mounting-flange profiles restored the real hole-to-edge clearance.
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 |
+| Parse total | 26.5759 ms |
+| Semantic + constraint resolution | 16.0116 ms |
+| Formed/profile lower | 70.3482 ms |
+| Authored flat lower | 57.5023 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.
@@ -32,12 +32,12 @@ 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` |
+| `ctc03-final.firmament` | `3A8C4A7C93C4750FE9241B4F4071F240108966F5AB0A28F1E81ABF7ABF16CA91` |
+| `ctc03-formed.step` | `8E049EC25E0B3F3C57A1F931C4D111C51BD9D840B3B53569A7771F764567F330` |
+| `ctc03-flat.step` | `8104D7C13DF87F838DC709171E7BEABCAECFDD3A62943B6D254B68E5DC11B9B5` |
+| `ctc03-flat.svg` | `24C95460BF669BA38A78CDFF9BE6E7E1051EE56F39C8E0018249B5BAE00C5B05` |
+| Flat IR deterministic hash | `e3ec913e24f65d220839bbdbfa2d909dd8bdeeaed87ecc9ccfc6c1be7a1d297c` |
## 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.
+Verdict: **acceptable bounded prototype**. Generic edge-composition IR, diagnostics, stable paths, non-CTC fixture, and real export/reimport tests are cleanly localized. Debt remains: the Profile adapter is regex/block based, Sheet Metal exposes only the repeated fragment pressure needed so far, semantic and constraint timing share one bucket, and cross-edge corner ownership is not implemented. There is no CTC-specific compiler branch or generator.
diff --git a/fixtures/FirmamentV2/Canonical/valid/profile-edge-attachment-plate.firmament b/fixtures/FirmamentV2/Canonical/valid/profile-edge-attachment-plate.firmament
new file mode 100644
index 00000000..8bef062a
--- /dev/null
+++ b/fixtures/FirmamentV2/Canonical/valid/profile-edge-attachment-plate.firmament
@@ -0,0 +1,16 @@
+Model EdgeAttachmentPlate {
+ Units: mm
+ Concept Struct Layout On XY {
+ Rect2 PlateBase { Center: [0mm, 0mm]; Size: [100mm, 60mm] }
+ EdgeProfile PlateBase.Bottom {
+ Notch CableNotch { FromStart: 18mm; Width: 8mm; Depth: 4mm; Side: Left }
+ Tab MountTab { CenteredAt: 50mm; Width: 12mm; Extension: 6mm; Side: Right }
+ }
+ EdgeProfile PlateBase.Top {
+ Cutback HandlingCutback { FromEnd: 10mm; Run: 8mm; Offset: 3mm; Side: Right }
+ }
+ }
+
+ Profile Plate From PlateBase
+ Struct Body { Extrude Solid { Profile: Plate; From: 0mm; To: 3mm } }
+}