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.csnew file mode 100644index 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.csindex 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.csindex 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.csnew file mode 100644index 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.csindex 756267dc..1b2b51d4 100644--- a/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs+++ b/Aetheris.SheetMetal.Tests/SheetMetalM8Tests.cs@@ -30,10 +30,12 @@ public sealed class SheetMetalM8TestsAssert.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.csnew file mode 100644index 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.csindex 905f5ccb..caf7cdf2 100644--- a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs@@ -287,32 +287,34 @@ internal static class AuthoredSheetMetalLoweringvar 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.csindex 99afe34b..b0bf6fa1 100644--- a/Aetheris.SheetMetal/SheetMetalConceptPaths.cs+++ b/Aetheris.SheetMetal/SheetMetalConceptPaths.cs@@ -43,6 +43,8 @@ public static class SheetMetalConceptPathsAdd(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.csindex 527521fd..22ff307a 100644--- a/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs+++ b/Aetheris.SheetMetal/SheetMetalSemanticLayout.cs@@ -8,6 +8,9 @@ public enum SheetMetalSemanticConstraintKind { RequiredMembers, EqualSize, Equalpublic 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 SheetMetalSemanticLayoutParservar 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 SheetMetalSemanticLayoutParsertabs.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 SheetMetalSemanticLayoutParserconstraints.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.mdnew file mode 100644index 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.mdindex 053e1498..c492908d 100644--- a/docs/language/semantic-profiles.md+++ b/docs/language/semantic-profiles.md@@ -55,3 +55,50 @@ Firmament Concept Path / ProfileEach 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.mdindex 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.mdindex 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 compositionCommand:@@ -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.mdindex 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.firmamentindex 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.stepindex 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.svgindex 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.stepindex 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.mdindex 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.firmamentnew file mode 100644index 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 } }+}