diff --git a/3d_models/NOTICE b/3d_models/NOTICE index d7eea18..78a667f 100644 --- a/3d_models/NOTICE +++ b/3d_models/NOTICE @@ -12,6 +12,12 @@ Source Location https://github.com/jamro/tiny-engineer/tree/main/3d_models +Optional HD1370A bottom-cover modification (Hanson Wen, 2026): +https://github.com/Hilo-Hilo/tiny-engineer/tree/feat/hd1370a-bottom-cover/3d_models + +The modified master includes a hidden HD1370A-only cover reference. Its editable +source, print exports and verification scripts are included in this source tree. + When distributing a specific revision, use the corresponding tagged release or commit URL. diff --git a/3d_models/README.md b/3d_models/README.md index ee05d69..43f2ad0 100644 --- a/3d_models/README.md +++ b/3d_models/README.md @@ -15,6 +15,10 @@ Two ways to get the mechanical set (same place in the build path): - **Print yourself** — use the **`.3mf` files in `parts/sg90/3mf/`**, **`parts/fs0307/3mf/`**, or **`parts/hd1370a/3mf/`**. Ready to print in an orientation that does not need supports. **PLA** or **PETG**. Start with [Print first](#print-first). - **No printer?** — order the aggregated sets from a third-party service: [order printed parts](../docs/3d/order-parts.md). Orders are at your own risk; fit can vary by provider and design revision. +### Optional HD1370A bottom cover + +An optional [T-shaped underside cover](parts/hd1370a/bottom-cover/README.md) is available as an editable Fusion design and [printable 3MF](parts/hd1370a/3mf/BottomCover.3mf). It follows the desk/chair perimeter and has four recessed M2 head seats with a flat exterior. **Prototype: CAD geometry checked; physical fit and screw retention unverified.** HD1370A only; not included in the normal part-set exports. + ### Print first **Home printers only.** Print these two small testers from that folder **before** the rest of the set. Do not print the full robot until both fit. Skip this step when ordering from a service (testers alone are rarely worth the min fee + shipping). diff --git a/3d_models/cad/TinyEngineer.f3d b/3d_models/cad/TinyEngineer.f3d index 1826377..4a1238e 100644 Binary files a/3d_models/cad/TinyEngineer.f3d and b/3d_models/cad/TinyEngineer.f3d differ diff --git a/3d_models/cad/bottom-cover/BottomCover_FitCheck_HD1370A.f3d b/3d_models/cad/bottom-cover/BottomCover_FitCheck_HD1370A.f3d new file mode 100644 index 0000000..c1fe514 Binary files /dev/null and b/3d_models/cad/bottom-cover/BottomCover_FitCheck_HD1370A.f3d differ diff --git a/3d_models/cad/bottom-cover/BottomCover_HD1370A.f3d b/3d_models/cad/bottom-cover/BottomCover_HD1370A.f3d new file mode 100644 index 0000000..6ac6623 Binary files /dev/null and b/3d_models/cad/bottom-cover/BottomCover_HD1370A.f3d differ diff --git a/3d_models/cad/bottom-cover/README.md b/3d_models/cad/bottom-cover/README.md new file mode 100644 index 0000000..e392487 --- /dev/null +++ b/3d_models/cad/bottom-cover/README.md @@ -0,0 +1,43 @@ +# HD1370A bottom-cover source + +See the [part documentation](../../parts/hd1370a/bottom-cover/README.md) for geometry, previews and the unresolved screw-retention limitation. + +`BottomCover_HD1370A.f3d` is the editable native cover. `BottomCover_FitCheck_HD1370A.f3d` contains the source desk/chair fixture and four reference screw envelopes. The master `../TinyEngineer.f3d` contains a hidden `OPTIONAL_BOTTOM_COVER_HD1370A` reference outside `PRINT_LAYOUT`; it must only be shown with the HD1370A preset. + +The fixed perimeter comes from `underside_profile.py`, serialized as exact lines/arcs in `underside-profile.json`. `source-alignment.json` records source occurrence transforms in the HD1370A frame. The source mating plane is mapped to Z=4.5 mm; the desk print export needs a 180° rotation about X and the chair a −59.3 mm translation in X. + +## Rebuild and check + +Use a clean checkout. Install the CAD dependencies into an isolated Python environment: + +```sh +python3 -m venv /tmp/tiny-engineer-cad-venv +/tmp/tiny-engineer-cad-venv/bin/pip install -r 3d_models/cad/bottom-cover/requirements.txt +/tmp/tiny-engineer-cad-venv/bin/python 3d_models/cad/bottom-cover/build_and_check.py +``` + +This writes the canonical STEP/STL/3MF exports, the aligned fixture and geometric checks. It first produces a CadQuery mesh; the following Fusion step replaces the 3MF with the native export. Do not confuse the full inspection assembly with the single printable cover. + +In Fusion's Text Commands panel, use **Txt** mode and run these scripts in order, substituting the absolute checkout path: + +```text +Python.RunScript "/absolute/checkout/3d_models/cad/bottom-cover/create_in_fusion.py" +Python.RunScript "/absolute/checkout/3d_models/cad/bottom-cover/verify_in_fusion.py" +Python.RunScript "/absolute/checkout/3d_models/cad/bottom-cover/present_in_fusion.py" +Python.RunScript "/absolute/checkout/3d_models/cad/bottom-cover/integrate_master_in_fusion.py" +``` + +Use a fresh Fusion session for a full rebuild: the verification/presentation scripts select the documents created by the first script. `integrate_master_in_fusion.py` replaces the optional reference in the master, checks the original parameters and geometry before saving. It reopens the saved archive, verifies preservation, then checks the HD1370A fit in that temporary inspection copy without saving preset changes. + +Then run: + +```sh +/tmp/tiny-engineer-cad-venv/bin/python 3d_models/cad/bottom-cover/verify_master_mates.py +/tmp/tiny-engineer-cad-venv/bin/python 3d_models/cad/bottom-cover/inspect_perimeter.py +/tmp/tiny-engineer-cad-venv/bin/python 3d_models/cad/bottom-cover/verify_print.py +/tmp/tiny-engineer-cad-venv/bin/python 3d_models/cad/bottom-cover/verify_head_seats.py +``` + +The JSON files are CAD/mesh evidence, not physical load or thread-engagement tests. Previews are generated from the imported CAD and actual print-file section. The original HD1370A mating STEP files are unchanged from the baseline revision recorded in `provenance.json`. + +CAD sources, scripts and exports in these CAD directories are CERN-OHL-S-2.0; retain [NOTICE](../../NOTICE). diff --git a/3d_models/cad/bottom-cover/build_and_check.py b/3d_models/cad/bottom-cover/build_and_check.py new file mode 100644 index 0000000..5b4b4ab --- /dev/null +++ b/3d_models/cad/bottom-cover/build_and_check.py @@ -0,0 +1,230 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Rebuild and inspect HD1370A bottom cover with CadQuery; dimensions in mm.""" +from pathlib import Path +import json, math +import cadquery as cq +import trimesh +from underside_profile import derive_profile, wire_from_segments + +ROOT = Path(__file__).resolve().parents[3] +OUT = ROOT / "3d_models/parts/hd1370a/bottom-cover" +SOURCES = ROOT / "3d_models/parts/hd1370a/step" +PARAMS = { + "thickness": 4.5, + "clearance": 0.3, + "hole_diameter": 2.3, + "head_diameter": 4.3, + "head_depth": 2.3, +} +HOLES = [(-30, -61.6), (26, -61.6), (-30, 61.6), (26, 61.6)] + + +def common_volume(a, b): + return a.intersect(b).Volume() + + +def mesh(s): + v, f = s.tessellate(0.025, 0.1) + return trimesh.Trimesh(vertices=[p.toTuple() for p in v], faces=f, process=True) + + +def build(): + OUT.mkdir(parents=True, exist_ok=True) + desk = ( + cq.importers.importStep(str(SOURCES / "Desk.step")) + .val() + .rotate((0, 0, 0), (1, 0, 0), 180) + .translate((0, 0, 38.5)) + ) + chair = ( + cq.importers.importStep(str(SOURCES / "Chair.step")) + .val() + .translate((-59.3, 0, 4.5)) + ) + source_wire, segments, source_edges, chair_rear = derive_profile(desk, chair) + (Path(__file__).parent / "underside-profile.json").write_text( + json.dumps( + { + "revision": 2, + "source": "Actual bottom planar rim of assembled HD1370A Desk and Chair", + "perimeter_offset_mm": 0, + "segments": segments, + }, + indent=2, + ) + + "\n" + ) + outline = wire_from_segments(segments) + p = cq.Workplane("XY").newObject( + [cq.Solid.extrudeLinear(outline, [], cq.Vector(0, 0, PARAMS["thickness"]))] + ) + for x, y in HOLES: + p = p.cut( + cq.Workplane("XY") + .center(x, y) + .circle(PARAMS["hole_diameter"] / 2) + .extrude(PARAMS["thickness"]) + ) + p = p.cut( + cq.Workplane("XY") + .center(x, y) + .circle(PARAMS["head_diameter"] / 2) + .extrude(PARAMS["head_depth"]) + ) + plate = p.val() + cq.exporters.export(plate, str(OUT.parent / "step/BottomCover.step")) + # Print top mating face on bed; counterbores open upward, with no bridges. + printable = plate.rotate((0, 0, 0), (1, 0, 0), 180).translate((0, 0, 4.5)) + m = mesh(printable) + m.metadata["units"] = "mm" + m.export(str(OUT.parent / "stl/BottomCover.stl")) + (OUT.parent / "3mf/BottomCover.3mf").write_bytes( + trimesh.exchange.threemf.export_3MF(trimesh.Scene(m)) + ) + desk = ( + cq.importers.importStep(str(SOURCES / "Desk.step")) + .val() + .rotate((0, 0, 0), (1, 0, 0), 180) + .translate((0, 0, 38.5)) + ) + chair = ( + cq.importers.importStep(str(SOURCES / "Chair.step")) + .val() + .translate((-59.3, 0, 4.5)) + ) + top = ( + cq.importers.importStep(str(SOURCES / "DeskTop.step")) + .val() + .translate((0, 0, 40.0)) + ) + pad = ( + cq.importers.importStep(str(SOURCES / "DeskPad.step")) + .val() + .translate((-2.0, 0.0000082699, 38.5)) + ) + ass = cq.Assembly(name="BottomCover_FitCheck_HD1370A") + for n, s, c in [ + ("BottomCover", plate, (0.08, 0.6, 0.72)), + ("Desk", desk, (0.35, 0.35, 0.38)), + ("Chair", chair, (0.48, 0.48, 0.5)), + ("DeskTop", top, (0.28, 0.28, 0.3)), + ("DeskPad", pad, (0.65, 0.5, 0.28)), + ]: + ass.add(s, name=n, color=cq.Color(*c)) + ass.export(str(OUT / "BottomCover_FitCheck.step")) + # Normalize exporter whitespace without changing STEP records. + for path in [ + OUT.parent / "step/BottomCover.step", + OUT / "BottomCover_FitCheck.step", + ]: + path.write_text( + "\n".join(line.rstrip() for line in path.read_text().splitlines()) + "\n" + ) + report = { + "parameters_mm": PARAMS, + "outline_segments_mm": segments, + "revision": 2, + "hole_centres_mm": HOLES, + "scope": "HD1370A only; CAD verified, physical print not yet fit-tested", + "assembly_transforms": { + "Desk": "rotate X 180 deg; translate (0,0,38.5) mm", + "Chair": "translate (-59.3,0,4.5) mm", + "DeskTop": "translate (0,0,40.0) mm", + "DeskPad": "translate (-2,0.0000082699,38.5) mm", + }, + "valid_solid": plate.isValid(), + "solid_count": len(plate.Solids()), + "mesh_watertight": m.is_watertight, + "mesh_winding_consistent": m.is_winding_consistent, + "mesh_euler_number": int(m.euler_number), + "volume_mm3": plate.Volume(), + "bounds_mm": m.bounds.tolist(), + "part_interference_mm3": {}, + "head_checks": [], + } + for n, s in [("Desk", desk), ("Chair", chair), ("DeskTop", top), ("DeskPad", pad)]: + report["part_interference_mm3"][n] = common_volume(plate, s) + # M2 conservative envelope from native source: 4 mm diameter x 2 mm head. + for x, y in HOLES: + head = cq.Solid.makeCylinder(2.0, 2.0, cq.Vector(x, y, 0.3)) + shaft = cq.Solid.makeCylinder(1.0, 6.0, cq.Vector(x, y, 2.3)) + report["head_checks"].append( + { + "centre_mm": [x, y], + "head_to_floor_clearance_mm": 0.3, + "radial_head_clearance_mm": 0.15, + "radial_shank_clearance_mm": 0.15, + "remaining_plate_bearing_mm": 2.2, + "M2x6_insertion_into_desk_mm": 3.8, + "head_plate_interference_mm3": common_volume(plate, head), + "shank_plate_interference_mm3": common_volume(plate, shaft), + "shank_desk_interference_mm3": common_volume(desk, shaft), + } + ) + # Compare the finished cover's actual mating-face exterior to the source + # underside, independently of the chosen hole geometry. + mating = ( + max( + [ + f + for f in plate.Faces() + if abs(f.BoundingBox().zmin - 4.5) < 1e-6 + and abs(f.BoundingBox().zmax - 4.5) < 1e-6 + ], + key=lambda f: f.Area(), + ) + .outerWire() + .translate((0, 0, -4.5)) + ) + expected_face = cq.Face.makeFromWires(source_wire) + actual_face = cq.Face.makeFromWires(mating) + overhang = actual_face.cut(expected_face).Area() + undercoverage = expected_face.cut(actual_face).Area() + dev = max( + mating.distance(cq.Vertex.makeVertex(*e.positionAt(i / 100).toTuple())) + for e in source_wire.Edges() + for i in range(101) + ) + report["perimeter_fit"] = { + "perimeter_offset_mm": 0, + "excess_footprint_area_mm2": overhang, + "missing_footprint_area_mm2": undercoverage, + "max_sampled_source_edge_deviation_mm": dev, + "copied_desk_edge_count": len(source_edges), + "radii_mm": [s["radius_mm"] for s in segments if s["type"] == "CIRCLE"], + "square_rear_corners_mm": [[-75.3, -35.6], [-75.3, 35.6]], + "rear_seam_bridges_mm": [0.3, 0.3], + "note": "Straight rear closure coincides with chair and desk rear planes and bridges only their two existing 0.3 mm assembly seams.", + } + assert overhang < 1e-6 and undercoverage < 1e-6 and dev < 1e-6 + # Exact STEP round trip plus print-3MF checks. + reread = cq.importers.importStep(str(OUT.parent / "step/BottomCover.step")).val() + scene = trimesh.load_scene(OUT.parent / "3mf/BottomCover.3mf") + report["step_roundtrip_valid"] = reread.isValid() + report["step_roundtrip_volume_error_mm3"] = abs(reread.Volume() - plate.Volume()) + report["3mf_mesh_count"] = len(scene.geometry) + report["3mf_bounds_mm"] = scene.bounds.tolist() + assert ( + plate.isValid() + and len(plate.Solids()) == 1 + and m.is_watertight + and m.euler_number == -6 + ) + assert all(abs(v) < 1e-6 for v in report["part_interference_mm3"].values()) + assert all( + abs(h[k]) < 1e-6 + for h in report["head_checks"] + for k in [ + "head_plate_interference_mm3", + "shank_plate_interference_mm3", + "shank_desk_interference_mm3", + ] + ) + (OUT / "verification.json").write_text(json.dumps(report, indent=2) + "\n") + print(json.dumps(report, indent=2)) + return plate, desk, chair + + +if __name__ == "__main__": + build() diff --git a/3d_models/cad/bottom-cover/create_in_fusion.py b/3d_models/cad/bottom-cover/create_in_fusion.py new file mode 100644 index 0000000..f365979 --- /dev/null +++ b/3d_models/cad/bottom-cover/create_in_fusion.py @@ -0,0 +1,252 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Run in Fusion (Python.RunScript) to build from the checked-in source assembly. +Creates a parametric cover, then imports the inspected desk/chair fit assembly. +Original TinyEngineer.f3d is never overwritten. All dimensions below are mm. +""" +import adsk.core, adsk.fusion, json, traceback +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[3] +OUT = ROOT / "3d_models/parts/hd1370a/bottom-cover" +CAD = ROOT / "3d_models/cad/bottom-cover" + + +def pt(x, y, z=0): + return adsk.core.Point3D.create(x / 10, y / 10, z / 10) + + +def val(s): + return adsk.core.ValueInput.createByString(s) + + +def collect(items): + c = adsk.core.ObjectCollection.create() + for item in items: + c.add(item) + return c + + +def extrude(comp, profile, distance, operation, name): + x = comp.features.extrudeFeatures.createInput(profile, operation) + x.setOneSideExtent( + adsk.fusion.DistanceExtentDefinition.create(val(distance)), + adsk.fusion.ExtentDirections.PositiveExtentDirection, + ) + f = comp.features.extrudeFeatures.add(x) + f.name = name + return f + + +def camera(app, eye, target, up, path): + cam = app.activeViewport.camera + cam.isSmoothTransition = False + cam.cameraType = adsk.core.CameraTypes.OrthographicCameraType + cam.eye = pt(*eye) + cam.target = pt(*target) + cam.upVector = adsk.core.Vector3D.create(*up) + cam.isFitView = True + app.activeViewport.camera = cam + app.activeViewport.refresh() + app.activeViewport.saveAsImageFile(str(path), 1400, 1000) + + +def main(): + app = adsk.core.Application.get() + source_doc = app.importManager.importToNewDocument( + app.importManager.createFusionArchiveImportOptions( + str(ROOT / "3d_models/cad/TinyEngineer.f3d") + ) + ) + source = adsk.fusion.Design.cast(app.activeProduct) + presets = json.loads( + (ROOT / "3d_models/fusion/TinyEngineerTools/servos.json").read_text() + ) + preset = next(p for p in presets.values() if p["servo_id"] == "hd1370a") + source.userParameters.itemByName("servo_id").expression = "'hd1370a'" + dims = [ + (source.userParameters.itemByName(k), val(v)) + for k, v in preset.items() + if k != "servo_id" + ] + assert source.modifyParameters([x[0] for x in dims], [x[1] for x in dims]) + source.computeAll() + for occ in source.rootComponent.occurrences: + if occ.component.name in [ + "ServoSizingTester", + "ScrewSizingTest", + "PRINT_LAYOUT", + "ASSEMBLY_GUIDE", + ]: + occ.isLightBulbOn = False + source_doc.name = "TinyEngineer HD1370A with Bottom Cover v2" + for occ in list(source.rootComponent.occurrences): + if occ.component.name == "OPTIONAL_BOTTOM_COVER_HD1370A": + occ.deleteMe() + doc = app.documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType) + doc.name = "BottomCover HD1370A v2" + d = adsk.fusion.Design.cast(app.activeProduct) + d.designType = adsk.fusion.DesignTypes.ParametricDesignType + d.unitsManager.distanceDisplayUnits = ( + adsk.fusion.DistanceUnits.MillimeterDistanceUnits + ) + root = d.rootComponent + for n, v, c in [ + ("plate_thickness", "4.5 mm", "Overall plate thickness"), + ("clearance", "0.3 mm", "Original robot CAD clearance"), + ("screw_diameter", "2 mm", "M2 nominal shaft diameter"), + ("screw_head_diameter", "4 mm", "Original CAD head envelope"), + ("screw_head_height", "2 mm", "Original CAD head height envelope"), + ]: + d.userParameters.add(n, val(v), "mm", c) + s = root.sketches.add(root.xYConstructionPlane) + s.name = "Exact underside rim - R3 desk, R1 shoulders, square chair" + profile = json.loads((CAD / "underside-profile.json").read_text()) + for seg in profile["segments"]: + if seg["type"] == "LINE": + curve = s.sketchCurves.sketchLines.addByTwoPoints( + pt(*seg["start_mm"]), pt(*seg["end_mm"]) + ) + else: + curve = s.sketchCurves.sketchArcs.addByThreePoints( + pt(*seg["start_mm"]), pt(*seg["mid_mm"]), pt(*seg["end_mm"]) + ) + curve.isFixed = True + assert s.profiles.count == 1 + f = extrude( + root, + s.profiles.item(0), + "plate_thickness", + adsk.fusion.FeatureOperations.NewBodyFeatureOperation, + "Plate - exact flush rim and flat floor", + ) + body = f.bodies.item(0) + body.name = "BottomCover" + holes = [(-30, -61.6), (26, -61.6), (-30, 61.6), (26, 61.6)] + for label, diam, depth in [ + ("M2 through holes", "screw_diameter + clearance", "plate_thickness"), + ( + "Recessed M2 heads on floor side", + "screw_head_diameter + clearance", + "screw_head_height + clearance", + ), + ]: + sk = root.sketches.add(root.xYConstructionPlane) + sk.name = label + for x, y in holes: + circle = sk.sketchCurves.sketchCircles.addByCenterRadius(pt(x, y), 0.1) + circle.centerSketchPoint.isFixed = True + sk.sketchDimensions.addDiameterDimension( + circle, pt(x + 5, y + 5) + ).parameter.expression = diam + extrude( + root, + collect([sk.profiles.item(i) for i in range(sk.profiles.count)]), + depth, + adsk.fusion.FeatureOperations.CutFeatureOperation, + label, + ) + sk.isVisible = False + s.isVisible = False + d.computeAll() + body = root.bRepBodies.item(0) + report = { + "revision": 2, + "outline_source": "underside-profile.json; actual underside edges with zero offset", + "body_count": root.bRepBodies.count, + "is_solid": body.isSolid, + "volume_mm3": body.volume * 1000, + "timeline_features": d.timeline.count, + "feature_health": [ + { + "name": f.name, + "state": int(f.healthState), + "message": f.errorOrWarningMessage, + } + for f in root.features + ], + } + ex = d.exportManager + assert ex.execute(ex.createSTEPExportOptions(str(OUT / "BottomCover_Fusion.step"))) + step_path = OUT / "BottomCover_Fusion.step" + step_path.write_text( + "\n".join(line.rstrip() for line in step_path.read_text().splitlines()) + "\n" + ) + camera( + app, (100, -140, -170), (-23, 0, 2.25), (0, 1, 0), OUT / "cover-underside.png" + ) + assert ex.execute( + ex.createFusionArchiveExportOptions(str(CAD / "BottomCover_HD1370A.f3d")) + ) + # Preserve the native source assembly, adding the CAD-generated cover at its exact global frame. + source_doc.activate() + opts = app.importManager.createSTEPImportOptions( + str(OUT.parent / "step/BottomCover.step") + ) + added = app.importManager.importToTarget2(opts, source.rootComponent) + new_occ = [x for x in added if x.objectType == adsk.fusion.Occurrence.classType()] + if not new_occ: + # Import can return bodies; put them in a named occurrence so alignment remains inspectable. + occ = source.rootComponent.occurrences.addNewComponent( + adsk.core.Matrix3D.create() + ) + for x in added: + if x.objectType == adsk.fusion.BRepBody.classType(): + x.moveToComponent(occ) + new_occ = [occ] + for o in new_occ: + o.component.name = "BottomCover_HD1370A" + t = adsk.core.Matrix3D.create() + t.translation = adsk.core.Vector3D.create(4.35, -1.39259877217, -1.54740122783) + o.transform2 = t + if source.snapshots.hasPendingSnapshot: + source.snapshots.add() + source.computeAll() + # Import the actual desk/chair STEP solids, already rotated from print coordinates and aligned. + fitdoc = app.importManager.importToNewDocument( + app.importManager.createSTEPImportOptions( + str(OUT / "BottomCover_FitCheck.step") + ) + ) + fitdoc.name = "BottomCover Fit Check HD1370A v2" + fit = adsk.fusion.Design.cast(app.activeProduct) + report["fit_occurrences"] = [ + {"path": o.fullPathName, "name": o.component.name} + for o in fit.rootComponent.allOccurrences + ] + occs = list(fit.rootComponent.allOccurrences) + cover = [ + o + for o in occs + if o.component.name.startswith("BottomCover") and o.bRepBodies.count + ][0] + report["interference"] = {} + for name in ["Desk", "Chair", "DeskTop", "DeskPad"]: + obj = [o for o in occs if o.component.name == name][0] + inp = fit.createInterferenceInput(collect([cover, obj])) + inp.areCoincidentFacesIncluded = False + results = fit.analyzeInterference(inp) + report["interference"][name] = results.count if results else 0 + report["source_global_offset_mm"] = [43.5, -13.9259877217, -15.4740122783] + (OUT / "fusion-verification.json").write_text(json.dumps(report, indent=2) + "\n") + assert fit.exportManager.execute( + fit.exportManager.createFusionArchiveExportOptions( + str(CAD / "BottomCover_FitCheck_HD1370A.f3d") + ) + ) + camera(app, (150, -180, 130), (-23, 0, 35), (0, 0, 1), OUT / "fit-isometric.png") + camera(app, (-170, -180, -170), (-23, 0, 12), (0, 0, 1), OUT / "fit-underside.png") + camera(app, (160, 0, 13), (-23, 0, 13), (0, 0, 1), OUT / "fit-front.png") + camera(app, (-23, -250, 20), (-23, 0, 20), (0, 0, 1), OUT / "fit-side.png") + camera(app, (-23, 0, -230), (-23, 0, 0), (1, 0, 0), OUT / "fit-bottom.png") + camera(app, (150, -180, 130), (-23, 0, 35), (0, 0, 1), OUT / "fit-isometric.png") + if (OUT / "fusion-build-error.txt").exists(): + (OUT / "fusion-build-error.txt").unlink() + print("Native cover, full assembly and fit check exported.") + + +try: + main() +except: + (OUT / "fusion-build-error.txt").write_text(traceback.format_exc()) + print(traceback.format_exc()) diff --git a/3d_models/cad/bottom-cover/inspect_perimeter.py b/3d_models/cad/bottom-cover/inspect_perimeter.py new file mode 100644 index 0000000..0c998c5 --- /dev/null +++ b/3d_models/cad/bottom-cover/inspect_perimeter.py @@ -0,0 +1,91 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Independent STEP comparison and all-corner inspection sheet.""" +from pathlib import Path +import cadquery as cq +import json, numpy as np +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +from underside_profile import derive_profile, bottom_faces + +ROOT = Path(__file__).resolve().parents[3] +OUT = ROOT / "3d_models/parts/hd1370a/bottom-cover" +SRC = ROOT / "3d_models/parts/hd1370a/step" +desk = ( + cq.importers.importStep(str(SRC / "Desk.step")) + .val() + .rotate((0, 0, 0), (1, 0, 0), 180) + .translate((0, 0, 38.5)) +) +chair = ( + cq.importers.importStep(str(SRC / "Chair.step")).val().translate((-59.3, 0, 4.5)) +) +expected, _, _, _ = derive_profile(desk, chair) +cover = cq.importers.importStep(str(OUT / "BottomCover_Fusion.step")).val() +actual = ( + max(bottom_faces(cover, 4.5), key=lambda f: f.Area()) + .outerWire() + .translate((0, 0, -4.5)) +) +ref = cq.importers.importStep(str(OUT.parent / "step/BottomCover.step")).val() +result = { + "revision": 2, + "fusion_vs_cadquery_symmetric_difference_mm3": cover.cut(ref).Volume() + + ref.cut(cover).Volume(), + "fusion_perimeter_excess_area_mm2": cq.Face.makeFromWires(actual) + .cut(cq.Face.makeFromWires(expected)) + .Area(), + "fusion_perimeter_missing_area_mm2": cq.Face.makeFromWires(expected) + .cut(cq.Face.makeFromWires(actual)) + .Area(), + "fusion_max_sampled_boundary_deviation_mm": max( + actual.distance(cq.Vertex.makeVertex(*e.positionAt(i / 100).toTuple())) + for e in expected.Edges() + for i in range(101) + ), +} +assert all(abs(v) < 1e-6 for k, v in result.items() if k != "revision"), result +(OUT / "perimeter-verification.json").write_text(json.dumps(result, indent=2) + "\n") +fig, axs = plt.subplots(3, 3, figsize=(13, 13), layout="constrained") +views = [ + ("Rear left - square", (-79, -68), (29, 39)), + ("Left shoulder - R3 / R1", (-37, -19), (32, 45)), + ("Desk left rear - R3", (-37, -24), (56, 69)), + ("Rear right - square", (-79, -68), (-39, -29)), + ("Complete underside", (-83, 37), (-72, 72)), + ("Desk left front - R3", (20, 34), (56, 69)), + ("Right shoulder - R3 / R1", (-37, -19), (-45, -32)), + ("Desk right rear - R3", (-37, -24), (-69, -56)), + ("Desk right front - R3", (20, 34), (-69, -56)), +] +for ax, (title, xlim, ylim) in zip(axs.flat, views): + for wire, color, ls, lw, label in [ + (actual, "#007e9c", "-", 3, "Cover edge"), + (expected, "#db6b25", "--", 1.5, "Original rim / rear closure"), + ]: + for i, e in enumerate(wire.Edges()): + arr = np.array([e.positionAt(t).toTuple() for t in np.linspace(0, 1, 201)]) + ax.plot( + arr[:, 0], + arr[:, 1], + color=color, + linestyle=ls, + linewidth=lw, + label=label if i == 0 else None, + ) + ax.set(xlim=xlim, ylim=ylim, title=title) + ax.set_aspect("equal") + ax.grid(alpha=0.15) + ax.tick_params(labelsize=8) + if title == "Complete underside": + ax.scatter([-30, 26, -30, 26], [-61.6, -61.6, 61.6, 61.6], s=9, color="#777777") +fig.suptitle( + "HD1370A bottom cover v2 | Exact underside perimeter\nAll dimensions in mm - zero CAD overhang or undercoverage", + fontsize=16, +) +handles, labels = axs[0, 0].get_legend_handles_labels() +fig.legend(handles, labels, loc="outside lower center", ncol=2, frameon=False) +fig.savefig(OUT / "perimeter-corner-check.png", dpi=150) +print(json.dumps(result, indent=2)) diff --git a/3d_models/cad/bottom-cover/integrate_master_in_fusion.py b/3d_models/cad/bottom-cover/integrate_master_in_fusion.py new file mode 100644 index 0000000..4238225 --- /dev/null +++ b/3d_models/cad/bottom-cover/integrate_master_in_fusion.py @@ -0,0 +1,171 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Run in Fusion to update the optional HD1370A reference in the master archive. + +The independent parametric cover remains the editable source. This reference is +hidden by default and outside PRINT_LAYOUT, so another servo's batch exports +cannot accidentally include this fixed HD1370A part. Original parameters and +geometry are checked before the master file is overwritten. +""" +import json +import traceback +from pathlib import Path + +import adsk.core +import adsk.fusion + +ROOT = Path(__file__).resolve().parents[3] +MASTER = ROOT / "3d_models/cad/TinyEngineer.f3d" +OUT = ROOT / "3d_models/parts/hd1370a/bottom-cover" +NAME = "OPTIONAL_BOTTOM_COVER_HD1370A" + + +def original_geometry(design): + result = {} + for occurrence in design.rootComponent.allOccurrences: + if occurrence.component.name == NAME: + continue + bodies = [] + for body in occurrence.bRepBodies: + box = body.preciseBoundingBox + bodies.append( + [body.volume * 1000] + + [ + v * 10 + for p in [box.minPoint, box.maxPoint] + for v in [p.x, p.y, p.z] + ] + ) + result[occurrence.fullPathName] = bodies + return result + + +def main(): + app = adsk.core.Application.get() + document = app.importManager.importToNewDocument( + app.importManager.createFusionArchiveImportOptions(str(MASTER)) + ) + document.name = "TinyEngineer master with optional HD1370A cover" + design = adsk.fusion.Design.cast(app.activeProduct) + root = design.rootComponent + for old in list(root.occurrences): + if old.component.name == NAME: + old.deleteMe() + baseline = original_geometry(design) + parameters = {p.name: p.expression for p in design.userParameters} + options = app.importManager.createSTEPImportOptions( + str(OUT.parent / "step/BottomCover.step") + ) + added = app.importManager.importToTarget2(options, root) + occurrences = [ + o for o in added if o.objectType == adsk.fusion.Occurrence.classType() + ] + assert len(occurrences) == 1 + cover = occurrences[0] + cover.component.name = NAME + transform = adsk.core.Matrix3D.create() + transform.translation = adsk.core.Vector3D.create( + 4.35, -1.39259877217, -1.54740122783 + ) + cover.transform2 = transform + cover.isLightBulbOn = False + if design.snapshots.hasPendingSnapshot: + design.snapshots.add() + assert original_geometry(design) == baseline + + report = { + "scope": "Optional HD1370A reference in current upstream master", + "thread_retention_verified": False, + "hd1370a_interference": {}, + "original_geometry_identical_before_save": original_geometry(design) + == baseline, + "original_user_parameters_preserved": { + p.name: p.expression for p in design.userParameters + } + == parameters, + "default_servo_expression": parameters["servo_id"], + "optional_component_hidden": not cover.isLightBulbOn, + "original_occurrence_count": len(baseline), + "outside_print_layout": cover.assemblyContext is None, + } + assert report["original_geometry_identical_before_save"] + assert report["original_user_parameters_preserved"] + assert report["outside_print_layout"] + assert design.exportManager.execute( + design.exportManager.createFusionArchiveExportOptions(str(MASTER)) + ) + document.close(False) + reopened = app.importManager.importToNewDocument( + app.importManager.createFusionArchiveImportOptions(str(MASTER)) + ) + design = adsk.fusion.Design.cast(app.activeProduct) + root = design.rootComponent + cover = next(o for o in root.occurrences if o.component.name == NAME) + assert not cover.isLightBulbOn + assert {p.name: p.expression for p in design.userParameters} == parameters + after = original_geometry(design) + assert baseline.keys() == after.keys() + errors = [] + for name, bodies in baseline.items(): + assert len(bodies) == len(after[name]) + for old, new in zip(bodies, after[name]): + errors.extend(abs(a - b) for a, b in zip(old, new)) + report["max_original_geometry_numeric_change_after_reopen"] = max(errors, default=0) + assert max(errors, default=0) < 0.001 + report["master_archive_reopened"] = True + report["cover_volume_mm3"] = cover.bRepBodies.item(0).volume * 1000 + + # Check the HD1370A preset in the reopened inspection copy only. Never save + # preset regeneration into the master: its original default stays untouched. + presets = json.loads( + (ROOT / "3d_models/fusion/TinyEngineerTools/servos.json").read_text() + ) + preset = next(p for p in presets.values() if p["servo_id"] == "hd1370a") + dimensions = [k for k in preset if k != "servo_id"] + design.userParameters.itemByName("servo_id").expression = "'hd1370a'" + assert design.modifyParameters( + [design.userParameters.itemByName(k) for k in dimensions], + [adsk.core.ValueInput.createByString(preset[k]) for k in dimensions], + ) + design.computeAll() + for name in ["Desk", "Chair", "DeskTop", "DeskPad"]: + part = next(o for o in root.occurrences if o.component.name == name) + objects = adsk.core.ObjectCollection.create() + objects.add(cover) + objects.add(part) + request = design.createInterferenceInput(objects) + request.areCoincidentFacesIncluded = False + result = design.analyzeInterference(request) + report["hd1370a_interference"][name] = result.count if result else 0 + assert all(n == 0 for n in report["hd1370a_interference"].values()) + temporary = adsk.fusion.TemporaryBRepManager.get() + native_parts = [] + for name in ["Desk", "Chair"]: + occurrence = next(o for o in root.occurrences if o.component.name == name) + native_parts.append((name, [temporary.copy(b) for b in occurrence.bRepBodies])) + reopened.close(False) + # Short-lived export documents are removed after the independent STEP is saved. + for name, bodies in native_parts: + doc = app.documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType) + model = adsk.fusion.Design.cast(app.activeProduct) + model.designType = adsk.fusion.DesignTypes.DirectDesignType + for body in bodies: + model.rootComponent.bRepBodies.add(body) + assert model.exportManager.execute( + model.exportManager.createSTEPExportOptions( + str(OUT / ("native-master-" + name + ".step")) + ) + ) + doc.close(False) + (OUT / "master-integration-verification.json").write_text( + json.dumps(report, indent=2) + "\n" + ) + (OUT / "master-integration-error.txt").unlink(missing_ok=True) + print("Master updated; original defaults and geometry preserved.") + + +try: + main() +except Exception: + (OUT / "master-integration-error.txt").write_text(traceback.format_exc()) + print(traceback.format_exc()) diff --git a/3d_models/cad/bottom-cover/present_in_fusion.py b/3d_models/cad/bottom-cover/present_in_fusion.py new file mode 100644 index 0000000..255e709 --- /dev/null +++ b/3d_models/cad/bottom-cover/present_in_fusion.py @@ -0,0 +1,92 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +import adsk.core, adsk.fusion, math, traceback +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[3] +C = ROOT / "3d_models/cad/bottom-cover" +O = ROOT / "3d_models/parts/hd1370a/bottom-cover" +app = adsk.core.Application.get() + + +def pt(xs): + return adsk.core.Point3D.create(*[x / 10 for x in xs]) + + +def view(eye, target, up, path, size=None): + cam = app.activeViewport.camera + cam.isSmoothTransition = False + cam.cameraType = adsk.core.CameraTypes.OrthographicCameraType + cam.eye = pt(eye) + cam.target = pt(target) + cam.upVector = adsk.core.Vector3D.create(*up) + cam.isFitView = size is None + if size: + cam.setExtents(size / 10, size / 10) + app.activeViewport.camera = cam + app.activeViewport.refresh() + app.activeViewport.saveAsImageFile(str(O / path), 1400, 1000) + + +try: + standalone = next( + doc for doc in app.documents if doc.name.startswith("BottomCover HD1370A v2") + ) + standalone.activate() + model = adsk.fusion.Design.cast(app.activeProduct) + tm = adsk.fusion.TemporaryBRepManager.get() + s = tm.copy(model.rootComponent.bRepBodies.item(0)) + t = adsk.core.Matrix3D.create() + t.setToRotation( + math.pi, adsk.core.Vector3D.create(1, 0, 0), adsk.core.Point3D.create(0, 0, 0) + ) + t.translation = adsk.core.Vector3D.create(0, 0, 0.45) + tm.transform(s, t) + pd = app.documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType) + d = adsk.fusion.Design.cast(app.activeProduct) + d.designType = adsk.fusion.DesignTypes.DirectDesignType + b = d.rootComponent.bRepBodies.add(s) + b.name = "BottomCover" + ex = d.exportManager + opt = ex.createC3MFExportOptions(b, str(O.parent / "3mf/BottomCover.3mf")) + opt.sendToPrintUtility = False + opt.meshRefinement = adsk.fusion.MeshRefinementSettings.MeshRefinementHigh + opt.surfaceDeviation = 0.0005 + opt.normalDeviation = math.radians(3) + assert ex.execute(opt) + pd.close(False) + fit = next( + doc + for doc in app.documents + if doc.name.startswith("BottomCover Fit Check HD1370A v2") + ) + fit.activate() + d = adsk.fusion.Design.cast(app.activeProduct) + for label, target, delta in [ + ("rear-left", (-75.3, 35.6, 4.5), (-40, 40, 18)), + ("rear-right", (-75.3, -35.6, 4.5), (-40, -40, 18)), + ("desk-left-front", (26, 61.6, 4.5), (40, 40, 18)), + ("desk-right-front", (26, -61.6, 4.5), (40, -40, 18)), + ("desk-left-rear", (-30, 61.6, 4.5), (-40, 40, 18)), + ("desk-right-rear", (-30, -61.6, 4.5), (-40, -40, 18)), + ("shoulder-left", (-28, 38, 4.5), (-40, 40, 10)), + ("shoulder-right", (-28, -38, 4.5), (-40, -40, 10)), + ]: + view( + tuple(a + b for a, b in zip(target, delta)), + target, + (0, 0, 1), + "corner-" + label + ".png", + 22, + ) + view((-170, -180, -170), (-23, 0, 12), (0, 0, 1), "fit-with-recessed-screws.png") + view((150, -180, 130), (-23, 0, 35), (0, 0, 1), "fit-isometric.png") + assert d.exportManager.execute( + d.exportManager.createFusionArchiveExportOptions( + str(C / "BottomCover_FitCheck_HD1370A.f3d") + ) + ) + app.userInterface.palettes.itemById("TextCommands").isVisible = False +except: + (O / "fusion-presentation-error.txt").write_text(traceback.format_exc()) + print(traceback.format_exc()) diff --git a/3d_models/cad/bottom-cover/provenance.json b/3d_models/cad/bottom-cover/provenance.json new file mode 100644 index 0000000..d2ee1f3 --- /dev/null +++ b/3d_models/cad/bottom-cover/provenance.json @@ -0,0 +1,11 @@ +{ + "baseline_commit": "44122c02e51962606ca31a676c6982ca534428ab", + "source_repository": "https://github.com/jamro/tiny-engineer", + "source_files_sha256": { + "3d_models/parts/hd1370a/step/Desk.step": "a7caa2b100eba380a9b46e8175cb07d1e2f999c8c6107419ca7616acbab5bbbc", + "3d_models/parts/hd1370a/step/Chair.step": "4ec4ec0c31622bca53362e94802d862a200f705d465e91b5dcd7badd51c367e8", + "3d_models/parts/hd1370a/step/DeskTop.step": "378180c4f255a3cdcb9b471d4a718e1339adb0e904dd370dbfccc9b000d31f30", + "3d_models/parts/hd1370a/step/DeskPad.step": "ef3503fd6fcbeec9cd4698258c3315ddc6b8fdb088da687aee051a5c58c190d5" + }, + "scope": "HD1370A only; physical fit and machine-screw retention unverified" +} diff --git a/3d_models/cad/bottom-cover/requirements.txt b/3d_models/cad/bottom-cover/requirements.txt new file mode 100644 index 0000000..0c3f993 --- /dev/null +++ b/3d_models/cad/bottom-cover/requirements.txt @@ -0,0 +1,7 @@ +cadquery==2.8.0 +trimesh==5.1.0 +numpy==2.4.6 +shapely==2.1.2 +matplotlib==3.11.2 +networkx==3.6.1 +lxml==6.1.3 diff --git a/3d_models/cad/bottom-cover/source-alignment.json b/3d_models/cad/bottom-cover/source-alignment.json new file mode 100644 index 0000000..7b8601b --- /dev/null +++ b/3d_models/cad/bottom-cover/source-alignment.json @@ -0,0 +1,542 @@ +[ + { + "path": "SeatLeft:1", + "name": "SeatLeft", + "bounds": [ + -26.500000000000217, + -13.925987721713778, + 4.32598772171505, + 20.500000000000576, + 16.374012278282265, + 22.6686284088344 + ], + "transform_cm": [ + 1.0, + -3.527952712637854e-14, + 5.91577606941886e-32, + 0.12000000000046163, + 3.527952712637854e-14, + 1.0, + 1.8318679906311214e-15, + -1.392598772171426, + -6.468659422812297e-29, + -1.8318679906311214e-15, + 1.0, + 6.372598772171466, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "Chair:1", + "name": "Chair", + "bounds": [ + -44.57536006147808, + -44.225987721704726, + -10.974012278285405, + 20.500000000041297, + 16.374012278285353, + 65.82067512076983 + ], + "transform_cm": [ + 1.0, + 5.695022027592894e-14, + 0.0, + 0.12000000000046596, + -5.695022027592894e-14, + 1.0, + 1.8318679906315075e-15, + -1.3925987721705524, + 1.0432528558288768e-28, + -1.8318679906315075e-15, + 1.0, + 6.372598772171421, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "Desk:1", + "name": "Desk", + "bounds": [ + -31.80000000005133, + -78.52598772185077, + -10.97401227835845, + 72.49999999996986, + 50.67401227824321, + 23.025987721714777 + ], + "transform_cm": [ + 1.0, + 2.5243548967072383e-29, + 4.871210800933708e-29, + 0.12000000000042599, + 0.0, + 1.0, + 1.0023135991346068e-15, + -1.3925987721747624, + -4.8712108009337125e-29, + -1.0023135991346068e-15, + 1.0, + 6.372598772171424, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "DeskPad:1", + "name": "DeskPad", + "bounds": [ + 6.699999999999642, + -82.32598772148904, + 23.025987721714554, + 76.29999999997592, + 54.4740122787514, + 28.02598772171455 + ], + "transform_cm": [ + 1.0, + -4.869512163528739e-44, + -4.3130936439853656e-46, + 0.12000000000042643, + 4.869512163528739e-44, + 1.0, + -7.083771681126353e-16, + -1.392598772174769, + 0.0, + 7.083771681126353e-16, + 1.0, + 6.372598772171424, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "DeskTop:1", + "name": "DeskTop", + "bounds": [ + 8.499999999634916, + -80.52598772185485, + 24.525987721714472, + 74.49999999987895, + 52.67401227871968, + 29.025987721714568 + ], + "transform_cm": [ + 1.0, + -4.869512163528739e-44, + -8.635093079366842e-46, + 0.11999999998636657, + 4.869512163528739e-44, + 1.0, + 1.0023135991347222e-15, + -1.3925987721536721, + 0.0, + -1.0023135991347222e-15, + 1.0, + 6.372598772171414, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "SeatRight:1", + "name": "SeatRight", + "bounds": [ + -26.499999999999567, + -44.225987721699475, + 4.325987721715183, + 20.50000000000057, + -13.92598772170321, + 22.6686284088344 + ], + "transform_cm": [ + 1.0, + 2.4404849212591685e-16, + 1.3805746559747736e-31, + 0.12000000000046152, + 2.4404849212591685e-16, + -1.0, + -2.7269427972045266e-15, + -1.3925987721703101, + -5.062223815950366e-31, + 2.7269427972045266e-15, + -1.0, + 6.372598772171466, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+SeatLeft:2", + "name": "SeatLeft", + "bounds": [ + -23.50000000001632, + -15.149999999996242, + -8.881784197001252e-15, + 23.49999999998382, + 15.150000000000016, + 18.342640687119285 + ], + "transform_cm": [ + 1.0, + 0.0, + 5.91577606941886e-32, + 0.4199999999987867, + 0.0, + 1.0, + -2.0870578231464366e-45, + -1.514999999999621, + -5.915776070777559e-32, + 0.0, + 1.0, + 5.939999999999955, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+SeatRight:2", + "name": "SeatRight", + "bounds": [ + -23.50000000001632, + -15.150000000000013, + -8.881784197001252e-15, + 23.49999999998382, + 15.149999999996247, + 18.342640687119285 + ], + "transform_cm": [ + 1.0, + 0.0, + 1.3805746559747736e-31, + 0.4199999999987867, + 0.0, + -1.0, + -3.369271630578999e-47, + 1.5149999999996215, + 1.5928389617635792e-31, + 0.0, + -1.0, + 5.939999999999955, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+Chair:2", + "name": "Chair", + "bounds": [ + -28.775360061478715, + -30.299999999994604, + -1.7763568394002505e-14, + 36.30000000004146, + 30.299999999995464, + 76.79468739905522 + ], + "transform_cm": [ + 1.0, + 2.805816078705122e-14, + 0.0, + 1.7000000000004745, + -2.805816078705122e-14, + 1.0, + 0.0, + 4.334310688136611e-13, + 0.0, + 0.0, + 1.0, + 7.4699999999999545, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+Desk:2", + "name": "Desk", + "bounds": [ + -75.30000000001212, + -64.59999999999269, + -1.509903313490213e-13, + 29.000000000009045, + 64.60000000010129, + 34.00000000007297 + ], + "transform_cm": [ + 1.0, + 2.5243548967072434e-29, + 4.871210800933708e-29, + -4.229999999995654, + 0.0, + -1.0, + 2.378359335458047e-72, + -1.787459069646502e-13, + 4.8712108009337125e-29, + 0.0, + -1.0, + -4.069999999999965, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+DeskPad:2", + "name": "DeskPad", + "bounds": [ + -34.79999999986425, + -68.40000826966482, + -7.105427357601002e-14, + 34.800000000112036, + 68.39999173057562, + 4.9999999999999245 + ], + "transform_cm": [ + 1.0, + 0.0, + -4.3130936439853656e-46, + -4.029999999985963, + 0.0, + 1.0, + 2.100266196182523e-89, + -8.269923448267491e-07, + -3.44945123649052e-59, + 0.0, + 1.0, + 4.069999999999966, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+DeskTop:2", + "name": "DeskTop", + "bounds": [ + -35.00000000018528, + -66.60000000031631, + -8.881784197001252e-15, + 31.000000000058755, + 66.60000000025822, + 4.500000000000051 + ], + "transform_cm": [ + 1.0, + 0.0, + -8.635093079366842e-46, + -4.229999999995653, + 0.0, + 1.0, + 4.204869078317967e-89, + 1.787459069646502e-13, + 4.880778262656798e-59, + 0.0, + 1.0, + 3.9199999999999657, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetA:1+DeskPad:3", + "name": "DeskPad", + "bounds": [ + -39.800000000014265, + -91.99999999974573, + -3.552713678800501e-14, + 29.799999999961994, + 44.800000000494734, + 4.99999999999996 + ], + "transform_cm": [ + 1.0, + -2.47609661627192e-16, + -4.3130936439853656e-46, + -4.530000000000966, + 2.47609661627192e-16, + 1.0, + -1.067963657753609e-61, + -2.360000000000434, + -3.44945123649052e-59, + 0.0, + 1.0, + 4.069999999999969, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetB:1+SeatLeft:3", + "name": "SeatLeft", + "bounds": [ + 37.97537791543979, + -120.10000000023948, + -2.220446049250313e-13, + 68.2753779154278, + -73.10000000021415, + 18.342640687119058 + ], + "transform_cm": [ + -1.3767479837065378e-12, + -1.0, + 2.2204460492532905e-16, + 6.827537791545159, + 1.0, + -1.3767479837065378e-12, + -2.220446049245263e-16, + -9.240000000021011, + 2.22044604924832e-16, + 2.2204460492502337e-16, + 1.0, + 5.939999999999933, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetB:1+SeatRight:3", + "name": "SeatRight", + "bounds": [ + -14.024622084535153, + -111.40000000020812, + -2.575717417130363e-13, + 32.97537791543979, + -81.10000000020362, + 18.342640687119047 + ], + "transform_cm": [ + 1.0, + 1.3768092160464953e-12, + 1.1348564968877153e-31, + 1.3675377915443838, + 1.3768092160464953e-12, + -1.0, + 2.220446049248321e-16, + -8.110000000022747, + 3.058724224170469e-28, + -2.220446049248321e-16, + -1.0, + 5.939999999999931, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetB:1+Chair:3", + "name": "Chair", + "bounds": [ + -103.07536006149037, + -102.19999999998277, + 3.552713678800501e-14, + -37.99999999996941, + -41.59999999999268, + 76.79468739905528 + ], + "transform_cm": [ + 1.0, + 0.0, + -1.6346518565469563e-58, + -5.73000000000062, + 0.0, + 1.0, + 2.774165281236589e-42, + -7.189999999998394, + 1.579893238482581e-55, + -2.774165281236589e-42, + 1.0, + 7.46999999999996, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetB:1+Desk:3", + "name": "Desk", + "bounds": [ + -75.30000000001212, + -64.59999999999269, + -1.509903313490213e-13, + 29.000000000009045, + 64.60000000010129, + 34.00000000007297 + ], + "transform_cm": [ + 1.0, + 2.5243548967072434e-29, + 4.871210800933708e-29, + -4.229999999995654, + 0.0, + -1.0, + 2.378359335458047e-72, + -1.787459069646502e-13, + 4.8712108009337125e-29, + 0.0, + -1.0, + -4.069999999999965, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "path": "PRINT_LAYOUT:1+PartsSetB:1+DeskTop:3", + "name": "DeskTop", + "bounds": [ + 33.99999999987898, + -66.6000000001773, + -4.884981308350689e-14, + 100.00000000029274, + 66.60000000039723, + 4.500000000000011 + ], + "transform_cm": [ + -1.0, + 1.377685844192893e-12, + -9.742421601867416e-29, + 10.729999999997913, + -1.377685844192893e-12, + -1.0, + -6.710998164525894e-41, + 9.60853618892088e-12, + -9.742421601867416e-29, + -8.040095640847692e-72, + 1.0, + 3.9199999999999617, + 0.0, + 0.0, + 0.0, + 1.0 + ] + } +] \ No newline at end of file diff --git a/3d_models/cad/bottom-cover/underside-profile.json b/3d_models/cad/bottom-cover/underside-profile.json new file mode 100644 index 0000000..f40db3c --- /dev/null +++ b/3d_models/cad/bottom-cover/underside-profile.json @@ -0,0 +1,299 @@ +{ + "revision": 2, + "source": "Actual bottom planar rim of assembled HD1370A Desk and Chair", + "perimeter_offset_mm": 0, + "segments": [ + { + "type": "LINE", + "start_mm": [ + -75.3, + 35.6 + ], + "end_mm": [ + -24.0, + 35.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -24.0, + 35.6 + ], + "end_mm": [ + -23.0, + 36.6 + ], + "mid_mm": [ + -23.292893219, + 35.892893219 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -23.0, + 36.6 + ], + "end_mm": [ + -23.0, + 37.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -23.0, + 37.6 + ], + "end_mm": [ + -24.0, + 38.6 + ], + "mid_mm": [ + -23.292893219, + 38.307106781 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -24.0, + 38.6 + ], + "end_mm": [ + -30.0, + 38.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -30.0, + 38.6 + ], + "end_mm": [ + -33.0, + 41.6 + ], + "mid_mm": [ + -32.121320344, + 39.478679656 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -33.0, + 41.6 + ], + "end_mm": [ + -33.0, + 61.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -33.0, + 61.6 + ], + "end_mm": [ + -30.0, + 64.6 + ], + "mid_mm": [ + -32.121320344, + 63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -30.0, + 64.6 + ], + "end_mm": [ + 26.0, + 64.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + 26.0, + 64.6 + ], + "end_mm": [ + 29.0, + 61.6 + ], + "mid_mm": [ + 28.121320344, + 63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + 29.0, + 61.6 + ], + "end_mm": [ + 29.0, + -61.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + 29.0, + -61.6 + ], + "end_mm": [ + 26.0, + -64.6 + ], + "mid_mm": [ + 28.121320343, + -63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + 26.0, + -64.6 + ], + "end_mm": [ + -30.0, + -64.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -30.0, + -64.6 + ], + "end_mm": [ + -33.0, + -61.6 + ], + "mid_mm": [ + -32.121320344, + -63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -33.0, + -61.6 + ], + "end_mm": [ + -33.0, + -41.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -33.0, + -41.6 + ], + "end_mm": [ + -30.0, + -38.6 + ], + "mid_mm": [ + -32.121320344, + -39.478679656 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -30.0, + -38.6 + ], + "end_mm": [ + -24.0, + -38.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -24.0, + -38.6 + ], + "end_mm": [ + -23.0, + -37.6 + ], + "mid_mm": [ + -23.292893219, + -38.307106781 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -23.0, + -37.6 + ], + "end_mm": [ + -23.0, + -36.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -23.0, + -36.6 + ], + "end_mm": [ + -24.0, + -35.6 + ], + "mid_mm": [ + -23.292893219, + -35.892893219 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -24.0, + -35.6 + ], + "end_mm": [ + -75.3, + -35.6 + ] + }, + { + "type": "LINE", + "start_mm": [ + -75.3, + -35.6 + ], + "end_mm": [ + -75.3, + 35.6 + ] + } + ] +} diff --git a/3d_models/cad/bottom-cover/underside_profile.py b/3d_models/cad/bottom-cover/underside_profile.py new file mode 100644 index 0000000..e7e2db4 --- /dev/null +++ b/3d_models/cad/bottom-cover/underside_profile.py @@ -0,0 +1,103 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Copy the real planar rim. No offset, projected overhang, or blanket fillets.""" +import cadquery as cq + +TOL = 1e-6 + + +def bottom_faces(shape, z): + return [ + f + for f in shape.Faces() + if abs(f.BoundingBox().zmin - z) < TOL and abs(f.BoundingBox().zmax - z) < TOL + ] + + +def key(v): + return tuple(round(c, 6) for c in v.toTuple()) + + +def derive_profile(desk, chair, z=4.5): + rim = max(bottom_faces(desk, z), key=lambda f: f.Area()) + edges = rim.outerWire().Edges() + pts = [e.startPoint() for e in edges] + [e.endPoint() for e in edges] + xmin = min(p.x for p in pts) + back = [p for p in pts if abs(p.x - xmin) < TOL] + a = max(back, key=lambda p: p.y) + b = min(back, key=lambda p: p.y) + # The original wall is an open C. Of the two rim paths between rear + # corners, the exterior is the one reaching the foremost desk wall. + paths = [] + for first in [ + e for e in edges if key(a) in (key(e.startPoint()), key(e.endPoint())) + ]: + path = [] + current = a + edge = first + used = set() + while True: + used.add(edges.index(edge)) + path.append(edge) + current = ( + edge.endPoint() + if key(current) == key(edge.startPoint()) + else edge.startPoint() + ) + if key(current) == key(b): + break + edge = next( + e + for i, e in enumerate(edges) + if i not in used + and key(current) in (key(e.startPoint()), key(e.endPoint())) + ) + paths.append(path) + exterior = max(paths, key=lambda es: max(e.BoundingBox().xmax for e in es)) + # The chair rear rim shares exactly the same X plane as the desk tips. + chair_rear = [ + e + for f in bottom_faces(chair, z) + for e in f.outerWire().Edges() + if e.geomType() == "LINE" + and abs(e.startPoint().x - xmin) < TOL + and abs(e.endPoint().x - xmin) < TOL + ] + assert chair_rear, "Chair rear plane must agree with the desk tips" + assert abs(sum(e.Length() for e in chair_rear) - 60.6) < TOL + closure = cq.Edge.makeLine(b, a) + original = cq.Wire.assembleEdges(exterior + [closure]).translate((0, 0, -z)) + # Export line/three-point-arc data for a native editable Fusion sketch. + segments = [] + current = a + for edge in exterior + [closure]: + end = ( + edge.endPoint() + if key(current) == key(edge.startPoint()) + else edge.startPoint() + ) + item = { + "type": edge.geomType(), + "start_mm": [round(current.x, 9), round(current.y, 9)], + "end_mm": [round(end.x, 9), round(end.y, 9)], + } + if edge.geomType() == "CIRCLE": + mid = edge.positionAt(0.5) + item["mid_mm"] = [round(mid.x, 9), round(mid.y, 9)] + item["radius_mm"] = round(edge.radius(), 9) + segments.append(item) + current = end + return original, segments, exterior, chair_rear + + +def wire_from_segments(segments): + edges = [] + for s in segments: + a = cq.Vector(*s["start_mm"], 0) + b = cq.Vector(*s["end_mm"], 0) + edges.append( + cq.Edge.makeLine(a, b) + if s["type"] == "LINE" + else cq.Edge.makeThreePointArc(a, cq.Vector(*s["mid_mm"], 0), b) + ) + return cq.Wire.assembleEdges(edges) diff --git a/3d_models/cad/bottom-cover/verify_head_seats.py b/3d_models/cad/bottom-cover/verify_head_seats.py new file mode 100644 index 0000000..9da90f7 --- /dev/null +++ b/3d_models/cad/bottom-cover/verify_head_seats.py @@ -0,0 +1,132 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +from pathlib import Path +import cadquery as cq +import trimesh, numpy as np, json +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +from matplotlib.patches import Polygon, Rectangle + +O = Path(__file__).resolve().parents[3] / "3d_models/parts/hd1370a/bottom-cover" +plate = cq.importers.importStep(str(O / "BottomCover_Fusion.step")).val() +centres = [(-30, -61.6), (26, -61.6), (-30, 61.6), (26, 61.6)] +checks = [] +for x, y in centres: + head = cq.Solid.makeCylinder(2, 2, cq.Vector(x, y, 0.3)) + pushed = head.translate((0, 0, 0.1)) + checks.append( + { + "centre_mm": [x, y], + "seated_head_collision_mm3": plate.intersect(head).Volume(), + "head_pushed_up_0p1mm_collision_mm3": plate.intersect(pushed).Volume(), + } + ) +assert all( + c["seated_head_collision_mm3"] < 1e-6 + and c["head_pushed_up_0p1mm_collision_mm3"] > 0.8 + for c in checks +) +m = trimesh.load_scene(O.parent / "3mf/BottomCover.3mf").to_mesh() +# Rotate print coordinates back into the installed orientation. +m.apply_transform(trimesh.transformations.rotation_matrix(np.pi, [1, 0, 0])) +m.apply_translation([0, 0, 4.5]) +x, y = centres[2] +section = m.section(plane_origin=[0, y, 0], plane_normal=[0, 1, 0]) +fig, ax = plt.subplots(figsize=(12, 7), layout="constrained") +for line in section.discrete: + ax.add_patch( + Polygon( + np.column_stack((line[:, 0] - x, line[:, 2])), + closed=True, + facecolor="#12839a", + edgecolor="#075769", + lw=1.5, + ) + ) +# Conservative envelope explicitly distinguished from a detailed screw model. +ax.add_patch( + Rectangle((-2, 0.3), 4, 2, facecolor="#a8adb4", edgecolor="#333b45", lw=1.5) +) +ax.add_patch( + Rectangle((-1, 2.3), 2, 6.0, facecolor="#a8adb4", edgecolor="#333b45", lw=1.5) +) +ax.axhline(0, color="#b45a21", lw=2) +ax.axhline(4.5, color="#777", ls=":", lw=1) +ax.annotate( + "Plastic shoulder stops the head", + xy=(-1.6, 2.3), + xytext=(-6.9, 6.3), + arrowprops={"arrowstyle": "->", "color": "#1e4b5a"}, + fontsize=12, + color="#163b48", +) +ax.annotate( + "2.2 mm of plastic above the head seat", + xy=(2.5, 3.4), + xytext=(3.1, 5.7), + arrowprops={"arrowstyle": "->", "color": "#1e4b5a"}, + fontsize=11, + color="#163b48", +) +ax.annotate( + "Shaft clearance: 2.3 mm", + xy=(-1.15, 3.5), + xytext=(-6.9, 4.6), + arrowprops={"arrowstyle": "->", "color": "#1e4b5a"}, + fontsize=11, +) +ax.annotate( + "Head recess: 4.3 mm wide\n2.3 mm deep", + xy=(2.15, 1.15), + xytext=(3.1, 1.3), + arrowprops={"arrowstyle": "->", "color": "#1e4b5a"}, + fontsize=11, +) +ax.annotate( + "Head stays 0.3 mm above the desk", + xy=(0, 0.15), + xytext=(-6.9, -1.5), + arrowprops={"arrowstyle": "->", "color": "#1e4b5a"}, + fontsize=11, +) +ax.text(3.1, 0.15, "Flat underside / desk surface", color="#9b4a1b", fontsize=10) +ax.text( + 0, + 8.9, + "Shaft continues into the robot\nThread grip is a separate fit requirement", + ha="center", + fontsize=11, +) +ax.set( + xlim=(-7.2, 9), + ylim=(-2.2, 10), + aspect="equal", + xlabel="Distance across one hole (mm)", + ylabel="Height above the flat underside (mm)", +) +ax.set_title( + "Actual printable file: cross-section through one screw hole\nTeal = printed cover; grey = 4 mm head / 2 mm shaft reference envelope", + loc="left", + fontsize=14, +) +ax.grid(alpha=0.10) +fig.savefig(O / "screw-seat-section.png", dpi=160) +(O / "screw-seat-check.json").write_text( + json.dumps( + { + "all_four_head_shoulders_present": True, + "checks": checks, + "through_hole_mm": 2.3, + "head_recess_mm": 4.3, + "recess_depth_mm": 2.3, + "plastic_above_head_seat_mm": 2.2, + "reference_head_overlap_per_side_mm": 0.85, + "scope": "Checks head retention against the cover only. Desk pilot thread engagement depends on actual screw and printed hole size; zero collision does not establish grip.", + }, + indent=2, + ) + + "\n" +) +print(json.dumps(checks, indent=2)) diff --git a/3d_models/cad/bottom-cover/verify_in_fusion.py b/3d_models/cad/bottom-cover/verify_in_fusion.py new file mode 100644 index 0000000..e6163f1 --- /dev/null +++ b/3d_models/cad/bottom-cover/verify_in_fusion.py @@ -0,0 +1,157 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +import adsk.core, adsk.fusion, json, traceback +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[3] +O = ROOT / "3d_models/parts/hd1370a/bottom-cover" +C = ROOT / "3d_models/cad/bottom-cover" + + +def col(xs): + c = adsk.core.ObjectCollection.create() + for x in xs: + c.add(x) + return c + + +def check(d, a, b): + i = d.createInterferenceInput(col([a, b])) + i.areCoincidentFacesIncluded = False + r = d.analyzeInterference(i) + return r.count if r else 0 + + +try: + app = adsk.core.Application.get() + srcdoc = next( + d + for d in app.documents + if d.name.startswith("TinyEngineer HD1370A with Bottom Cover v2") + ) + srcdoc.activate() + d = adsk.fusion.Design.cast(app.activeProduct) + cover = next( + o + for o in d.rootComponent.allOccurrences + if o.component.name == "BottomCover_HD1370A" + ) + out = { + "revision": 2, + "thread_retention_verified": False, + "full_original_assembly_interference": {}, + } + for o in d.rootComponent.occurrences: + if o.component.name in ["Desk", "Chair", "DeskTop", "DeskPad"]: + out["full_original_assembly_interference"][o.component.name] = check( + d, cover, o + ) + fitdoc = next( + doc + for doc in app.documents + if doc.name.startswith("BottomCover Fit Check HD1370A v2") + ) + fitdoc.activate() + d = adsk.fusion.Design.cast(app.activeProduct) + root = d.rootComponent + cover = next(o for o in root.allOccurrences if o.component.name == "BottomCover") + desk = next(o for o in root.allOccurrences if o.component.name == "Desk") + # Geometric screw envelopes; not printed parts and not helical thread models. + out["screw_envelopes"] = [] + for idx, (x, y) in enumerate( + [(-30, -61.6), (26, -61.6), (-30, 61.6), (26, 61.6)], 1 + ): + occ = root.occurrences.addNewComponent(adsk.core.Matrix3D.create()) + occ.component.name = "M2x6 head envelope " + str(idx) + " (REFERENCE ONLY)" + tm = adsk.fusion.TemporaryBRepManager.get() + a = adsk.core.Point3D.create(x / 10, y / 10, 0.03) + b = adsk.core.Point3D.create(x / 10, y / 10, 0.23) + c = adsk.core.Point3D.create(x / 10, y / 10, 0.83) + h = tm.createCylinderOrCone(a, 0.2, b, 0.2) + s = tm.createCylinderOrCone(b, 0.1, c, 0.1) + tm.booleanOperation(h, s, adsk.fusion.BooleanTypes.UnionBooleanType) + bf = occ.component.features.baseFeatures.add() + bf.startEdit() + body = occ.component.bRepBodies.add(h, bf) + bf.finishEdit() + body.name = "M2x6 envelope - do not print" + out["screw_envelopes"].append( + { + "head_floor_gap_mm": body.preciseBoundingBox.minPoint.z * 10, + "cover_interference": check(d, cover, occ), + "desk_interference": check(d, desk, occ), + } + ) + # Save screw reference assembly, default visible to inspect recesses. + app.activeViewport.refresh() + assert d.exportManager.execute( + d.exportManager.createFusionArchiveExportOptions( + str(C / "BottomCover_FitCheck_HD1370A.f3d") + ) + ) + out["all_geometric_checks_pass"] = all( + v == 0 for v in out["full_original_assembly_interference"].values() + ) and all( + r["cover_interference"] == 0 + and r["desk_interference"] == 0 + and r["head_floor_gap_mm"] > 0 + for r in out["screw_envelopes"] + ) + assert out["all_geometric_checks_pass"], out + (O / "fusion-final-checks.json").write_text(json.dumps(out, indent=2) + "\n") + # Print export from native parametric Fusion body, transformed in a separate local document. + standalone = next( + doc + for doc in app.documents + if doc.name.startswith("BottomCover HD1370A v2") + and doc.products.itemByProductType( + "DesignProductType" + ).rootComponent.bRepBodies.count + == 1 + ) + standalone.activate() + model = adsk.fusion.Design.cast(app.activeProduct) + tm = adsk.fusion.TemporaryBRepManager.get() + s = tm.copy(model.rootComponent.bRepBodies.item(0)) + import math + + t = adsk.core.Matrix3D.create() + t.setToRotation( + math.pi, adsk.core.Vector3D.create(1, 0, 0), adsk.core.Point3D.create(0, 0, 0) + ) + t.translation = adsk.core.Vector3D.create(0, 0, 0.45) + tm.transform(s, t) + printdoc = app.documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType) + printdoc.name = "BottomCover print orientation" + pd = adsk.fusion.Design.cast(app.activeProduct) + pd.designType = adsk.fusion.DesignTypes.DirectDesignType + b = pd.rootComponent.bRepBodies.add(s) + b.name = "BottomCover" + ex = pd.exportManager + opt = ex.createC3MFExportOptions(b, str(O.parent / "3mf/BottomCover.3mf")) + opt.sendToPrintUtility = False + opt.meshRefinement = adsk.fusion.MeshRefinementSettings.MeshRefinementHigh + opt.surfaceDeviation = 0.0005 + opt.normalDeviation = math.radians(3) + assert ex.execute(opt) + printdoc.close(False) + reopened = app.importManager.importToNewDocument( + app.importManager.createFusionArchiveImportOptions( + str(C / "BottomCover_HD1370A.f3d") + ) + ) + rd = adsk.fusion.Design.cast(app.activeProduct) + out["native_f3d_reopened"] = { + "body_count": rd.rootComponent.bRepBodies.count, + "volume_mm3": rd.rootComponent.bRepBodies.item(0).volume * 1000, + "timeline_count": rd.timeline.count, + } + (O / "fusion-final-checks.json").write_text(json.dumps(out, indent=2) + "\n") + reopened.close(False) + fitdoc.activate() + err = O / "fusion-build-error.txt" + if err.exists(): + err.unlink() +except: + (O / "fusion-final-error.txt").write_text(traceback.format_exc()) + print(traceback.format_exc()) diff --git a/3d_models/cad/bottom-cover/verify_master_mates.py b/3d_models/cad/bottom-cover/verify_master_mates.py new file mode 100644 index 0000000..4b429b0 --- /dev/null +++ b/3d_models/cad/bottom-cover/verify_master_mates.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Check native master mating parts against the unchanged HD1370A fixture. + +Run after integrate_master_in_fusion.py. Uses volume, topology counts and +bidirectional edge samples; coincident STEP booleans are unreliable for these +complex imported parts. This is a sampled comparison, not a boolean proof. +""" +import json +from pathlib import Path + +import cadquery as cq + +ROOT = Path(__file__).resolve().parents[3] +PARTS = ROOT / "3d_models/parts/hd1370a" +OUT = PARTS / "bottom-cover" + + +def sampled_edge_distance(source, target): + return max( + target.distance(cq.Vertex.makeVertex(*edge.positionAt(i / 10).toTuple())) + for edge in source.Edges() + for i in range(11) + ) + + +report_path = OUT / "master-integration-verification.json" +report = json.loads(report_path.read_text()) +report["native_master_mate_comparison"] = {} +for name in ["Desk", "Chair"]: + native = cq.importers.importStep(str(OUT / f"native-master-{name}.step")).val() + fixture = cq.importers.importStep(str(PARTS / "step" / f"{name}.step")).val() + if name == "Desk": + fixture = fixture.rotate((0, 0, 0), (1, 0, 0), 180).translate((0, 0, 38.5)) + else: + fixture = fixture.translate((-59.3, 0, 4.5)) + fixture = fixture.translate((43.5, -13.9259877217, -15.4740122783)) + result = { + "valid_solids": native.isValid() and fixture.isValid(), + "volume_difference_mm3": abs(native.Volume() - fixture.Volume()), + "face_counts": [len(native.Faces()), len(fixture.Faces())], + "edge_counts": [len(native.Edges()), len(fixture.Edges())], + "native_to_fixture_max_sampled_edge_distance_mm": sampled_edge_distance( + native, fixture + ), + "fixture_to_native_max_sampled_edge_distance_mm": sampled_edge_distance( + fixture, native + ), + "samples_per_edge": 11, + } + assert result["valid_solids"] + assert result["volume_difference_mm3"] < 1e-6 + assert result["face_counts"][0] == result["face_counts"][1] + assert result["edge_counts"][0] == result["edge_counts"][1] + assert result["native_to_fixture_max_sampled_edge_distance_mm"] < 1e-6 + assert result["fixture_to_native_max_sampled_edge_distance_mm"] < 1e-6 + report["native_master_mate_comparison"][name] = result +report_path.write_text(json.dumps(report, indent=2) + "\n") +# These inspection exports duplicate existing sources and are not deliverables. +for name in ["Desk", "Chair"]: + (OUT / f"native-master-{name}.step").unlink() +print(json.dumps(report["native_master_mate_comparison"], indent=2)) diff --git a/3d_models/cad/bottom-cover/verify_print.py b/3d_models/cad/bottom-cover/verify_print.py new file mode 100644 index 0000000..80bbbf6 --- /dev/null +++ b/3d_models/cad/bottom-cover/verify_print.py @@ -0,0 +1,41 @@ +# SPDX-FileCopyrightText: 2026 Hanson Wen +# SPDX-License-Identifier: CERN-OHL-S-2.0 +"""Check the native Fusion print export, including recess orientation.""" +import trimesh, json, numpy as np +from pathlib import Path + +p = Path(__file__).resolve().parents[3] / "3d_models/parts/hd1370a/bottom-cover" +s = trimesh.load_scene(p.parent / "3mf/BottomCover.3mf") +m = s.to_mesh() +out = { + "revision": 2, + "mesh_count": len(s.geometry), + "bounds_mm": s.bounds.tolist(), + "extents_mm": s.extents.tolist(), + "watertight": m.is_watertight, + "winding_consistent": m.is_winding_consistent, + "euler_number": int(m.euler_number), + "volume_mm3": float(m.volume), + "units": "mm", + "sections": [], +} +for z in [0.5, 3.5]: + sec = m.section(plane_origin=[0, 0, z], plane_normal=[0, 0, 1]) + flat, mat = sec.to_2D() + polys = sorted(flat.polygons_closed, key=lambda x: x.area) + holes = polys[:4] + dias = [float(2 * np.sqrt(poly.area / np.pi)) for poly in holes] + out["sections"].append( + {"height_from_print_bed_mm": z, "hole_equivalent_diameters_mm": dias} + ) + assert len(polys) == 5 + assert all(abs(v - (2.3 if z == 0.5 else 4.3)) < 0.01 for v in dias), dias +assert ( + len(s.geometry) == 1 + and m.is_watertight + and m.is_winding_consistent + and m.euler_number == -6 +) +assert np.allclose(s.extents, [104.3, 129.2, 4.5], atol=1e-4) +(p / "print-verification.json").write_text(json.dumps(out, indent=2) + "\n") +print(json.dumps(out, indent=2)) diff --git a/3d_models/parts/hd1370a/.gitattributes b/3d_models/parts/hd1370a/.gitattributes new file mode 100644 index 0000000..529294b --- /dev/null +++ b/3d_models/parts/hd1370a/.gitattributes @@ -0,0 +1,4 @@ +# Generated STEP exports; review the native CAD, scripts and previews. +step/BottomCover.step linguist-generated=true +bottom-cover/BottomCover_Fusion.step linguist-generated=true +bottom-cover/BottomCover_FitCheck.step linguist-generated=true diff --git a/3d_models/parts/hd1370a/3mf/BottomCover.3mf b/3d_models/parts/hd1370a/3mf/BottomCover.3mf new file mode 100644 index 0000000..a2a091e Binary files /dev/null and b/3d_models/parts/hd1370a/3mf/BottomCover.3mf differ diff --git a/3d_models/parts/hd1370a/README.md b/3d_models/parts/hd1370a/README.md index 41f7fb7..cbbb392 100644 --- a/3d_models/parts/hd1370a/README.md +++ b/3d_models/parts/hd1370a/README.md @@ -15,3 +15,7 @@ - `servo_mount_hole_radius`: 1 mm - `servo_mount_hole_depth_offset`: 0 mm - `servo_mount_hole_width_offset`: 0 mm + +## Optional accessory + +[Bottom cover](bottom-cover/README.md): T-shaped, with recessed M2 head seats. CAD checked; physical fit and screw retention remain unverified. diff --git a/3d_models/parts/hd1370a/bottom-cover/BottomCover_FitCheck.step b/3d_models/parts/hd1370a/bottom-cover/BottomCover_FitCheck.step new file mode 100644 index 0000000..523abeb --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/BottomCover_FitCheck.step @@ -0,0 +1,42295 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('Open CASCADE Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2026-09-25T20:33:02',('Author'),( + 'Open CASCADE'),'Open CASCADE STEP processor 7.9','Open CASCADE 7.9' + ,'Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('BottomCover_FitCheck_HD1370A', + 'BottomCover_FitCheck_HD1370A','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31),#35); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,-0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,-0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(0.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,-0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(0.,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,-0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(0.,0.,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,-0.)); +#35 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#39)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#36,#37,#38)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#36 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#37 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#38 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#39 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(5.E-06),#36, + 'distance_accuracy_value','confusion accuracy'); +#40 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#41 = SHAPE_DEFINITION_REPRESENTATION(#42,#48); +#42 = PRODUCT_DEFINITION_SHAPE('','',#43); +#43 = PRODUCT_DEFINITION('design','',#44,#47); +#44 = PRODUCT_DEFINITION_FORMATION('','',#45); +#45 = PRODUCT('BottomCover','BottomCover','',(#46)); +#46 = PRODUCT_CONTEXT('',#2,'mechanical'); +#47 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#48 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#49),#2579); +#49 = MANIFOLD_SOLID_BREP('',#50); +#50 = CLOSED_SHELL('',(#51,#171,#247,#333,#1020,#1622,#1649,#1676,#1703, + #1730,#1757,#1784,#1811,#1838,#1865,#1892,#1919,#1946,#1973,#2000, + #2027,#2054,#2081,#2108,#2115,#2170,#2225,#2280,#2335,#2389,#2443, + #2497,#2551,#2558,#2565,#2572)); +#51 = ADVANCED_FACE('',(#52),#66,.T.); +#52 = FACE_BOUND('',#53,.T.); +#53 = EDGE_LOOP('',(#54,#89,#117,#145)); +#54 = ORIENTED_EDGE('',*,*,#55,.T.); +#55 = EDGE_CURVE('',#56,#58,#60,.T.); +#56 = VERTEX_POINT('',#57); +#57 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#58 = VERTEX_POINT('',#59); +#59 = CARTESIAN_POINT('',(-75.3,35.6,4.5)); +#60 = SURFACE_CURVE('',#61,(#65,#77),.PCURVE_S1.); +#61 = LINE('',#62,#63); +#62 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#63 = VECTOR('',#64,1.); +#64 = DIRECTION('',(0.,0.,1.)); +#65 = PCURVE('',#66,#71); +#66 = PLANE('',#67); +#67 = AXIS2_PLACEMENT_3D('',#68,#69,#70); +#68 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#69 = DIRECTION('',(0.,1.,0.)); +#70 = DIRECTION('',(1.,0.,0.)); +#71 = DEFINITIONAL_REPRESENTATION('',(#72),#76); +#72 = LINE('',#73,#74); +#73 = CARTESIAN_POINT('',(0.,0.)); +#74 = VECTOR('',#75,1.); +#75 = DIRECTION('',(0.,-1.)); +#76 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#77 = PCURVE('',#78,#83); +#78 = PLANE('',#79); +#79 = AXIS2_PLACEMENT_3D('',#80,#81,#82); +#80 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#81 = DIRECTION('',(-1.,0.,0.)); +#82 = DIRECTION('',(0.,1.,0.)); +#83 = DEFINITIONAL_REPRESENTATION('',(#84),#88); +#84 = LINE('',#85,#86); +#85 = CARTESIAN_POINT('',(71.2,0.)); +#86 = VECTOR('',#87,1.); +#87 = DIRECTION('',(0.,-1.)); +#88 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#89 = ORIENTED_EDGE('',*,*,#90,.T.); +#90 = EDGE_CURVE('',#58,#91,#93,.T.); +#91 = VERTEX_POINT('',#92); +#92 = CARTESIAN_POINT('',(-24.,35.6,4.5)); +#93 = SURFACE_CURVE('',#94,(#98,#105),.PCURVE_S1.); +#94 = LINE('',#95,#96); +#95 = CARTESIAN_POINT('',(-75.3,35.6,4.5)); +#96 = VECTOR('',#97,1.); +#97 = DIRECTION('',(1.,0.,0.)); +#98 = PCURVE('',#66,#99); +#99 = DEFINITIONAL_REPRESENTATION('',(#100),#104); +#100 = LINE('',#101,#102); +#101 = CARTESIAN_POINT('',(0.,-4.5)); +#102 = VECTOR('',#103,1.); +#103 = DIRECTION('',(1.,0.)); +#104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#105 = PCURVE('',#106,#111); +#106 = PLANE('',#107); +#107 = AXIS2_PLACEMENT_3D('',#108,#109,#110); +#108 = CARTESIAN_POINT('',(-18.65791794382,8.530512611009E-11,4.5)); +#109 = DIRECTION('',(-0.,-0.,-1.)); +#110 = DIRECTION('',(-1.,0.,0.)); +#111 = DEFINITIONAL_REPRESENTATION('',(#112),#116); +#112 = LINE('',#113,#114); +#113 = CARTESIAN_POINT('',(56.642082056175,35.599999999915)); +#114 = VECTOR('',#115,1.); +#115 = DIRECTION('',(-1.,0.)); +#116 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#117 = ORIENTED_EDGE('',*,*,#118,.F.); +#118 = EDGE_CURVE('',#119,#91,#121,.T.); +#119 = VERTEX_POINT('',#120); +#120 = CARTESIAN_POINT('',(-24.,35.6,0.)); +#121 = SURFACE_CURVE('',#122,(#126,#133),.PCURVE_S1.); +#122 = LINE('',#123,#124); +#123 = CARTESIAN_POINT('',(-24.,35.6,0.)); +#124 = VECTOR('',#125,1.); +#125 = DIRECTION('',(0.,0.,1.)); +#126 = PCURVE('',#66,#127); +#127 = DEFINITIONAL_REPRESENTATION('',(#128),#132); +#128 = LINE('',#129,#130); +#129 = CARTESIAN_POINT('',(51.3,0.)); +#130 = VECTOR('',#131,1.); +#131 = DIRECTION('',(0.,-1.)); +#132 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#133 = PCURVE('',#134,#139); +#134 = CYLINDRICAL_SURFACE('',#135,1.000000000637); +#135 = AXIS2_PLACEMENT_3D('',#136,#137,#138); +#136 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,0.)); +#137 = DIRECTION('',(-0.,-0.,-1.)); +#138 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#139 = DEFINITIONAL_REPRESENTATION('',(#140),#144); +#140 = LINE('',#141,#142); +#141 = CARTESIAN_POINT('',(-0.,0.)); +#142 = VECTOR('',#143,1.); +#143 = DIRECTION('',(-0.,-1.)); +#144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#145 = ORIENTED_EDGE('',*,*,#146,.F.); +#146 = EDGE_CURVE('',#56,#119,#147,.T.); +#147 = SURFACE_CURVE('',#148,(#152,#159),.PCURVE_S1.); +#148 = LINE('',#149,#150); +#149 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#150 = VECTOR('',#151,1.); +#151 = DIRECTION('',(1.,0.,0.)); +#152 = PCURVE('',#66,#153); +#153 = DEFINITIONAL_REPRESENTATION('',(#154),#158); +#154 = LINE('',#155,#156); +#155 = CARTESIAN_POINT('',(0.,0.)); +#156 = VECTOR('',#157,1.); +#157 = DIRECTION('',(1.,0.)); +#158 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#159 = PCURVE('',#160,#165); +#160 = PLANE('',#161); +#161 = AXIS2_PLACEMENT_3D('',#162,#163,#164); +#162 = CARTESIAN_POINT('',(-18.65791794382,8.530512611009E-11,0.)); +#163 = DIRECTION('',(-0.,-0.,-1.)); +#164 = DIRECTION('',(-1.,0.,0.)); +#165 = DEFINITIONAL_REPRESENTATION('',(#166),#170); +#166 = LINE('',#167,#168); +#167 = CARTESIAN_POINT('',(56.642082056175,35.599999999915)); +#168 = VECTOR('',#169,1.); +#169 = DIRECTION('',(-1.,0.)); +#170 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#171 = ADVANCED_FACE('',(#172),#78,.T.); +#172 = FACE_BOUND('',#173,.T.); +#173 = EDGE_LOOP('',(#174,#204,#225,#226)); +#174 = ORIENTED_EDGE('',*,*,#175,.T.); +#175 = EDGE_CURVE('',#176,#178,#180,.T.); +#176 = VERTEX_POINT('',#177); +#177 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#178 = VERTEX_POINT('',#179); +#179 = CARTESIAN_POINT('',(-75.3,-35.6,4.5)); +#180 = SURFACE_CURVE('',#181,(#185,#192),.PCURVE_S1.); +#181 = LINE('',#182,#183); +#182 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#183 = VECTOR('',#184,1.); +#184 = DIRECTION('',(0.,0.,1.)); +#185 = PCURVE('',#78,#186); +#186 = DEFINITIONAL_REPRESENTATION('',(#187),#191); +#187 = LINE('',#188,#189); +#188 = CARTESIAN_POINT('',(0.,0.)); +#189 = VECTOR('',#190,1.); +#190 = DIRECTION('',(0.,-1.)); +#191 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#192 = PCURVE('',#193,#198); +#193 = PLANE('',#194); +#194 = AXIS2_PLACEMENT_3D('',#195,#196,#197); +#195 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#196 = DIRECTION('',(0.,-1.,0.)); +#197 = DIRECTION('',(-1.,0.,0.)); +#198 = DEFINITIONAL_REPRESENTATION('',(#199),#203); +#199 = LINE('',#200,#201); +#200 = CARTESIAN_POINT('',(51.3,0.)); +#201 = VECTOR('',#202,1.); +#202 = DIRECTION('',(0.,-1.)); +#203 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#204 = ORIENTED_EDGE('',*,*,#205,.T.); +#205 = EDGE_CURVE('',#178,#58,#206,.T.); +#206 = SURFACE_CURVE('',#207,(#211,#218),.PCURVE_S1.); +#207 = LINE('',#208,#209); +#208 = CARTESIAN_POINT('',(-75.3,-35.6,4.5)); +#209 = VECTOR('',#210,1.); +#210 = DIRECTION('',(0.,1.,0.)); +#211 = PCURVE('',#78,#212); +#212 = DEFINITIONAL_REPRESENTATION('',(#213),#217); +#213 = LINE('',#214,#215); +#214 = CARTESIAN_POINT('',(0.,-4.5)); +#215 = VECTOR('',#216,1.); +#216 = DIRECTION('',(1.,0.)); +#217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#218 = PCURVE('',#106,#219); +#219 = DEFINITIONAL_REPRESENTATION('',(#220),#224); +#220 = LINE('',#221,#222); +#221 = CARTESIAN_POINT('',(56.642082056175,-35.60000000008)); +#222 = VECTOR('',#223,1.); +#223 = DIRECTION('',(0.,1.)); +#224 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#225 = ORIENTED_EDGE('',*,*,#55,.F.); +#226 = ORIENTED_EDGE('',*,*,#227,.F.); +#227 = EDGE_CURVE('',#176,#56,#228,.T.); +#228 = SURFACE_CURVE('',#229,(#233,#240),.PCURVE_S1.); +#229 = LINE('',#230,#231); +#230 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#231 = VECTOR('',#232,1.); +#232 = DIRECTION('',(0.,1.,0.)); +#233 = PCURVE('',#78,#234); +#234 = DEFINITIONAL_REPRESENTATION('',(#235),#239); +#235 = LINE('',#236,#237); +#236 = CARTESIAN_POINT('',(0.,0.)); +#237 = VECTOR('',#238,1.); +#238 = DIRECTION('',(1.,0.)); +#239 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#240 = PCURVE('',#160,#241); +#241 = DEFINITIONAL_REPRESENTATION('',(#242),#246); +#242 = LINE('',#243,#244); +#243 = CARTESIAN_POINT('',(56.642082056175,-35.60000000008)); +#244 = VECTOR('',#245,1.); +#245 = DIRECTION('',(0.,1.)); +#246 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#247 = ADVANCED_FACE('',(#248),#134,.F.); +#248 = FACE_BOUND('',#249,.T.); +#249 = EDGE_LOOP('',(#250,#251,#279,#307)); +#250 = ORIENTED_EDGE('',*,*,#118,.T.); +#251 = ORIENTED_EDGE('',*,*,#252,.T.); +#252 = EDGE_CURVE('',#91,#253,#255,.T.); +#253 = VERTEX_POINT('',#254); +#254 = CARTESIAN_POINT('',(-23.,36.6,4.5)); +#255 = SURFACE_CURVE('',#256,(#261,#268),.PCURVE_S1.); +#256 = CIRCLE('',#257,1.000000000637); +#257 = AXIS2_PLACEMENT_3D('',#258,#259,#260); +#258 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,4.5)); +#259 = DIRECTION('',(0.,0.,1.)); +#260 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#261 = PCURVE('',#134,#262); +#262 = DEFINITIONAL_REPRESENTATION('',(#263),#267); +#263 = LINE('',#264,#265); +#264 = CARTESIAN_POINT('',(-0.,-4.5)); +#265 = VECTOR('',#266,1.); +#266 = DIRECTION('',(-1.,0.)); +#267 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#268 = PCURVE('',#106,#269); +#269 = DEFINITIONAL_REPRESENTATION('',(#270),#278); +#270 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#271,#272,#273,#274,#275,#276 +,#277),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#271 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#272 = CARTESIAN_POINT('',(3.610031247503,35.600000001018)); +#273 = CARTESIAN_POINT('',(4.476056652794,37.100000001422)); +#274 = CARTESIAN_POINT('',(5.342082058085,38.600000001825)); +#275 = CARTESIAN_POINT('',(6.208107461466,37.100000000318)); +#276 = CARTESIAN_POINT('',(7.074132864847,35.599999998812)); +#277 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#278 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#279 = ORIENTED_EDGE('',*,*,#280,.F.); +#280 = EDGE_CURVE('',#281,#253,#283,.T.); +#281 = VERTEX_POINT('',#282); +#282 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#283 = SURFACE_CURVE('',#284,(#288,#295),.PCURVE_S1.); +#284 = LINE('',#285,#286); +#285 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#286 = VECTOR('',#287,1.); +#287 = DIRECTION('',(0.,0.,1.)); +#288 = PCURVE('',#134,#289); +#289 = DEFINITIONAL_REPRESENTATION('',(#290),#294); +#290 = LINE('',#291,#292); +#291 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#292 = VECTOR('',#293,1.); +#293 = DIRECTION('',(-0.,-1.)); +#294 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#295 = PCURVE('',#296,#301); +#296 = PLANE('',#297); +#297 = AXIS2_PLACEMENT_3D('',#298,#299,#300); +#298 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#299 = DIRECTION('',(-1.,0.,0.)); +#300 = DIRECTION('',(0.,1.,0.)); +#301 = DEFINITIONAL_REPRESENTATION('',(#302),#306); +#302 = LINE('',#303,#304); +#303 = CARTESIAN_POINT('',(0.,0.)); +#304 = VECTOR('',#305,1.); +#305 = DIRECTION('',(0.,-1.)); +#306 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#307 = ORIENTED_EDGE('',*,*,#308,.F.); +#308 = EDGE_CURVE('',#119,#281,#309,.T.); +#309 = SURFACE_CURVE('',#310,(#315,#322),.PCURVE_S1.); +#310 = CIRCLE('',#311,1.000000000637); +#311 = AXIS2_PLACEMENT_3D('',#312,#313,#314); +#312 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,0.)); +#313 = DIRECTION('',(0.,0.,1.)); +#314 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#315 = PCURVE('',#134,#316); +#316 = DEFINITIONAL_REPRESENTATION('',(#317),#321); +#317 = LINE('',#318,#319); +#318 = CARTESIAN_POINT('',(-0.,0.)); +#319 = VECTOR('',#320,1.); +#320 = DIRECTION('',(-1.,0.)); +#321 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#322 = PCURVE('',#160,#323); +#323 = DEFINITIONAL_REPRESENTATION('',(#324),#332); +#324 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#325,#326,#327,#328,#329,#330 +,#331),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#325 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#326 = CARTESIAN_POINT('',(3.610031247503,35.600000001018)); +#327 = CARTESIAN_POINT('',(4.476056652794,37.100000001422)); +#328 = CARTESIAN_POINT('',(5.342082058085,38.600000001825)); +#329 = CARTESIAN_POINT('',(6.208107461466,37.100000000318)); +#330 = CARTESIAN_POINT('',(7.074132864847,35.599999998812)); +#331 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#332 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#333 = ADVANCED_FACE('',(#334,#880,#915,#950,#985),#160,.T.); +#334 = FACE_BOUND('',#335,.T.); +#335 = EDGE_LOOP('',(#336,#337,#338,#361,#394,#422,#451,#479,#508,#536, + #565,#593,#622,#650,#679,#707,#736,#764,#797,#825,#858,#879)); +#336 = ORIENTED_EDGE('',*,*,#146,.T.); +#337 = ORIENTED_EDGE('',*,*,#308,.T.); +#338 = ORIENTED_EDGE('',*,*,#339,.T.); +#339 = EDGE_CURVE('',#281,#340,#342,.T.); +#340 = VERTEX_POINT('',#341); +#341 = CARTESIAN_POINT('',(-23.,37.6,0.)); +#342 = SURFACE_CURVE('',#343,(#347,#354),.PCURVE_S1.); +#343 = LINE('',#344,#345); +#344 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#345 = VECTOR('',#346,1.); +#346 = DIRECTION('',(0.,1.,0.)); +#347 = PCURVE('',#160,#348); +#348 = DEFINITIONAL_REPRESENTATION('',(#349),#353); +#349 = LINE('',#350,#351); +#350 = CARTESIAN_POINT('',(4.342082056175,36.599999999915)); +#351 = VECTOR('',#352,1.); +#352 = DIRECTION('',(0.,1.)); +#353 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#354 = PCURVE('',#296,#355); +#355 = DEFINITIONAL_REPRESENTATION('',(#356),#360); +#356 = LINE('',#357,#358); +#357 = CARTESIAN_POINT('',(0.,0.)); +#358 = VECTOR('',#359,1.); +#359 = DIRECTION('',(1.,0.)); +#360 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#361 = ORIENTED_EDGE('',*,*,#362,.T.); +#362 = EDGE_CURVE('',#340,#363,#365,.T.); +#363 = VERTEX_POINT('',#364); +#364 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#365 = SURFACE_CURVE('',#366,(#371,#382),.PCURVE_S1.); +#366 = CIRCLE('',#367,1.000000000637); +#367 = AXIS2_PLACEMENT_3D('',#368,#369,#370); +#368 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,0.)); +#369 = DIRECTION('',(0.,0.,1.)); +#370 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#371 = PCURVE('',#160,#372); +#372 = DEFINITIONAL_REPRESENTATION('',(#373),#381); +#373 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#374,#375,#376,#377,#378,#379 +,#380),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#374 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#375 = CARTESIAN_POINT('',(4.342082057278,39.332050808587)); +#376 = CARTESIAN_POINT('',(5.842082057682,38.466025403295)); +#377 = CARTESIAN_POINT('',(7.342082058085,37.599999998004)); +#378 = CARTESIAN_POINT('',(5.842082056578,36.733974594623)); +#379 = CARTESIAN_POINT('',(4.342082055072,35.867949191243)); +#380 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#381 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#382 = PCURVE('',#383,#388); +#383 = CYLINDRICAL_SURFACE('',#384,1.000000000637); +#384 = AXIS2_PLACEMENT_3D('',#385,#386,#387); +#385 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,0.)); +#386 = DIRECTION('',(-0.,-0.,-1.)); +#387 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#388 = DEFINITIONAL_REPRESENTATION('',(#389),#393); +#389 = LINE('',#390,#391); +#390 = CARTESIAN_POINT('',(-0.,0.)); +#391 = VECTOR('',#392,1.); +#392 = DIRECTION('',(-1.,0.)); +#393 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#394 = ORIENTED_EDGE('',*,*,#395,.T.); +#395 = EDGE_CURVE('',#363,#396,#398,.T.); +#396 = VERTEX_POINT('',#397); +#397 = CARTESIAN_POINT('',(-30.,38.6,0.)); +#398 = SURFACE_CURVE('',#399,(#403,#410),.PCURVE_S1.); +#399 = LINE('',#400,#401); +#400 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#401 = VECTOR('',#402,1.); +#402 = DIRECTION('',(-1.,0.,0.)); +#403 = PCURVE('',#160,#404); +#404 = DEFINITIONAL_REPRESENTATION('',(#405),#409); +#405 = LINE('',#406,#407); +#406 = CARTESIAN_POINT('',(5.342082056175,38.599999999915)); +#407 = VECTOR('',#408,1.); +#408 = DIRECTION('',(1.,0.)); +#409 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#410 = PCURVE('',#411,#416); +#411 = PLANE('',#412); +#412 = AXIS2_PLACEMENT_3D('',#413,#414,#415); +#413 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#414 = DIRECTION('',(0.,-1.,0.)); +#415 = DIRECTION('',(-1.,0.,0.)); +#416 = DEFINITIONAL_REPRESENTATION('',(#417),#421); +#417 = LINE('',#418,#419); +#418 = CARTESIAN_POINT('',(0.,-0.)); +#419 = VECTOR('',#420,1.); +#420 = DIRECTION('',(1.,0.)); +#421 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#422 = ORIENTED_EDGE('',*,*,#423,.T.); +#423 = EDGE_CURVE('',#396,#424,#426,.T.); +#424 = VERTEX_POINT('',#425); +#425 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#426 = SURFACE_CURVE('',#427,(#432,#439),.PCURVE_S1.); +#427 = CIRCLE('',#428,2.999999998497); +#428 = AXIS2_PLACEMENT_3D('',#429,#430,#431); +#429 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,0.)); +#430 = DIRECTION('',(0.,0.,-1.)); +#431 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#432 = PCURVE('',#160,#433); +#433 = DEFINITIONAL_REPRESENTATION('',(#434),#438); +#434 = CIRCLE('',#435,2.999999998497); +#435 = AXIS2_PLACEMENT_2D('',#436,#437); +#436 = CARTESIAN_POINT('',(11.342082057678,41.599999998411)); +#437 = DIRECTION('',(-5.011588183996E-10,-1.)); +#438 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#439 = PCURVE('',#440,#445); +#440 = CYLINDRICAL_SURFACE('',#441,2.999999998497); +#441 = AXIS2_PLACEMENT_3D('',#442,#443,#444); +#442 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,0.)); +#443 = DIRECTION('',(0.,0.,-1.)); +#444 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#445 = DEFINITIONAL_REPRESENTATION('',(#446),#450); +#446 = LINE('',#447,#448); +#447 = CARTESIAN_POINT('',(0.,0.)); +#448 = VECTOR('',#449,1.); +#449 = DIRECTION('',(1.,0.)); +#450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#451 = ORIENTED_EDGE('',*,*,#452,.T.); +#452 = EDGE_CURVE('',#424,#453,#455,.T.); +#453 = VERTEX_POINT('',#454); +#454 = CARTESIAN_POINT('',(-33.,61.6,0.)); +#455 = SURFACE_CURVE('',#456,(#460,#467),.PCURVE_S1.); +#456 = LINE('',#457,#458); +#457 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#458 = VECTOR('',#459,1.); +#459 = DIRECTION('',(0.,1.,0.)); +#460 = PCURVE('',#160,#461); +#461 = DEFINITIONAL_REPRESENTATION('',(#462),#466); +#462 = LINE('',#463,#464); +#463 = CARTESIAN_POINT('',(14.342082056175,41.599999999915)); +#464 = VECTOR('',#465,1.); +#465 = DIRECTION('',(0.,1.)); +#466 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#467 = PCURVE('',#468,#473); +#468 = PLANE('',#469); +#469 = AXIS2_PLACEMENT_3D('',#470,#471,#472); +#470 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#471 = DIRECTION('',(-1.,0.,0.)); +#472 = DIRECTION('',(0.,1.,0.)); +#473 = DEFINITIONAL_REPRESENTATION('',(#474),#478); +#474 = LINE('',#475,#476); +#475 = CARTESIAN_POINT('',(0.,0.)); +#476 = VECTOR('',#477,1.); +#477 = DIRECTION('',(1.,0.)); +#478 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#479 = ORIENTED_EDGE('',*,*,#480,.T.); +#480 = EDGE_CURVE('',#453,#481,#483,.T.); +#481 = VERTEX_POINT('',#482); +#482 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#483 = SURFACE_CURVE('',#484,(#489,#496),.PCURVE_S1.); +#484 = CIRCLE('',#485,2.999999998497); +#485 = AXIS2_PLACEMENT_3D('',#486,#487,#488); +#486 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,0.)); +#487 = DIRECTION('',(0.,0.,-1.)); +#488 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#489 = PCURVE('',#160,#490); +#490 = DEFINITIONAL_REPRESENTATION('',(#491),#495); +#491 = CIRCLE('',#492,2.999999998497); +#492 = AXIS2_PLACEMENT_2D('',#493,#494); +#493 = CARTESIAN_POINT('',(11.342082057678,61.600000001418)); +#494 = DIRECTION('',(1.,-5.011576341617E-10)); +#495 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#496 = PCURVE('',#497,#502); +#497 = CYLINDRICAL_SURFACE('',#498,2.999999998497); +#498 = AXIS2_PLACEMENT_3D('',#499,#500,#501); +#499 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,0.)); +#500 = DIRECTION('',(0.,0.,-1.)); +#501 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#502 = DEFINITIONAL_REPRESENTATION('',(#503),#507); +#503 = LINE('',#504,#505); +#504 = CARTESIAN_POINT('',(0.,0.)); +#505 = VECTOR('',#506,1.); +#506 = DIRECTION('',(1.,0.)); +#507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#508 = ORIENTED_EDGE('',*,*,#509,.T.); +#509 = EDGE_CURVE('',#481,#510,#512,.T.); +#510 = VERTEX_POINT('',#511); +#511 = CARTESIAN_POINT('',(26.,64.6,0.)); +#512 = SURFACE_CURVE('',#513,(#517,#524),.PCURVE_S1.); +#513 = LINE('',#514,#515); +#514 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#515 = VECTOR('',#516,1.); +#516 = DIRECTION('',(1.,0.,0.)); +#517 = PCURVE('',#160,#518); +#518 = DEFINITIONAL_REPRESENTATION('',(#519),#523); +#519 = LINE('',#520,#521); +#520 = CARTESIAN_POINT('',(11.342082056175,64.599999999915)); +#521 = VECTOR('',#522,1.); +#522 = DIRECTION('',(-1.,0.)); +#523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#524 = PCURVE('',#525,#530); +#525 = PLANE('',#526); +#526 = AXIS2_PLACEMENT_3D('',#527,#528,#529); +#527 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#528 = DIRECTION('',(0.,1.,0.)); +#529 = DIRECTION('',(1.,0.,0.)); +#530 = DEFINITIONAL_REPRESENTATION('',(#531),#535); +#531 = LINE('',#532,#533); +#532 = CARTESIAN_POINT('',(0.,0.)); +#533 = VECTOR('',#534,1.); +#534 = DIRECTION('',(1.,0.)); +#535 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#536 = ORIENTED_EDGE('',*,*,#537,.T.); +#537 = EDGE_CURVE('',#510,#538,#540,.T.); +#538 = VERTEX_POINT('',#539); +#539 = CARTESIAN_POINT('',(29.,61.6,0.)); +#540 = SURFACE_CURVE('',#541,(#546,#553),.PCURVE_S1.); +#541 = CIRCLE('',#542,2.999999998497); +#542 = AXIS2_PLACEMENT_3D('',#543,#544,#545); +#543 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,0.)); +#544 = DIRECTION('',(0.,0.,-1.)); +#545 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#546 = PCURVE('',#160,#547); +#547 = DEFINITIONAL_REPRESENTATION('',(#548),#552); +#548 = CIRCLE('',#549,2.999999998497); +#549 = AXIS2_PLACEMENT_2D('',#550,#551); +#550 = CARTESIAN_POINT('',(-44.65791794532,61.600000001418)); +#551 = DIRECTION('',(5.011611868754E-10,1.)); +#552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#553 = PCURVE('',#554,#559); +#554 = CYLINDRICAL_SURFACE('',#555,2.999999998497); +#555 = AXIS2_PLACEMENT_3D('',#556,#557,#558); +#556 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,0.)); +#557 = DIRECTION('',(0.,0.,-1.)); +#558 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#559 = DEFINITIONAL_REPRESENTATION('',(#560),#564); +#560 = LINE('',#561,#562); +#561 = CARTESIAN_POINT('',(0.,0.)); +#562 = VECTOR('',#563,1.); +#563 = DIRECTION('',(1.,0.)); +#564 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#565 = ORIENTED_EDGE('',*,*,#566,.T.); +#566 = EDGE_CURVE('',#538,#567,#569,.T.); +#567 = VERTEX_POINT('',#568); +#568 = CARTESIAN_POINT('',(29.,-61.6,0.)); +#569 = SURFACE_CURVE('',#570,(#574,#581),.PCURVE_S1.); +#570 = LINE('',#571,#572); +#571 = CARTESIAN_POINT('',(29.,61.6,0.)); +#572 = VECTOR('',#573,1.); +#573 = DIRECTION('',(0.,-1.,0.)); +#574 = PCURVE('',#160,#575); +#575 = DEFINITIONAL_REPRESENTATION('',(#576),#580); +#576 = LINE('',#577,#578); +#577 = CARTESIAN_POINT('',(-47.65791794382,61.599999999915)); +#578 = VECTOR('',#579,1.); +#579 = DIRECTION('',(0.,-1.)); +#580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#581 = PCURVE('',#582,#587); +#582 = PLANE('',#583); +#583 = AXIS2_PLACEMENT_3D('',#584,#585,#586); +#584 = CARTESIAN_POINT('',(29.,61.6,0.)); +#585 = DIRECTION('',(1.,0.,-0.)); +#586 = DIRECTION('',(0.,-1.,0.)); +#587 = DEFINITIONAL_REPRESENTATION('',(#588),#592); +#588 = LINE('',#589,#590); +#589 = CARTESIAN_POINT('',(0.,0.)); +#590 = VECTOR('',#591,1.); +#591 = DIRECTION('',(1.,0.)); +#592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#593 = ORIENTED_EDGE('',*,*,#594,.T.); +#594 = EDGE_CURVE('',#567,#595,#597,.T.); +#595 = VERTEX_POINT('',#596); +#596 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#597 = SURFACE_CURVE('',#598,(#603,#610),.PCURVE_S1.); +#598 = CIRCLE('',#599,3.000000000204); +#599 = AXIS2_PLACEMENT_3D('',#600,#601,#602); +#600 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,0.)); +#601 = DIRECTION('',(0.,0.,-1.)); +#602 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#603 = PCURVE('',#160,#604); +#604 = DEFINITIONAL_REPRESENTATION('',(#605),#609); +#605 = CIRCLE('',#606,3.000000000204); +#606 = AXIS2_PLACEMENT_2D('',#607,#608); +#607 = CARTESIAN_POINT('',(-44.65791794362,-61.59999999988)); +#608 = DIRECTION('',(-1.,-6.787814754256E-11)); +#609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#610 = PCURVE('',#611,#616); +#611 = CYLINDRICAL_SURFACE('',#612,3.000000000204); +#612 = AXIS2_PLACEMENT_3D('',#613,#614,#615); +#613 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,0.)); +#614 = DIRECTION('',(0.,0.,-1.)); +#615 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#616 = DEFINITIONAL_REPRESENTATION('',(#617),#621); +#617 = LINE('',#618,#619); +#618 = CARTESIAN_POINT('',(0.,0.)); +#619 = VECTOR('',#620,1.); +#620 = DIRECTION('',(1.,0.)); +#621 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#622 = ORIENTED_EDGE('',*,*,#623,.T.); +#623 = EDGE_CURVE('',#595,#624,#626,.T.); +#624 = VERTEX_POINT('',#625); +#625 = CARTESIAN_POINT('',(-30.,-64.6,0.)); +#626 = SURFACE_CURVE('',#627,(#631,#638),.PCURVE_S1.); +#627 = LINE('',#628,#629); +#628 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#629 = VECTOR('',#630,1.); +#630 = DIRECTION('',(-1.,0.,0.)); +#631 = PCURVE('',#160,#632); +#632 = DEFINITIONAL_REPRESENTATION('',(#633),#637); +#633 = LINE('',#634,#635); +#634 = CARTESIAN_POINT('',(-44.65791794382,-64.60000000008)); +#635 = VECTOR('',#636,1.); +#636 = DIRECTION('',(1.,0.)); +#637 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#638 = PCURVE('',#639,#644); +#639 = PLANE('',#640); +#640 = AXIS2_PLACEMENT_3D('',#641,#642,#643); +#641 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#642 = DIRECTION('',(0.,-1.,0.)); +#643 = DIRECTION('',(-1.,0.,0.)); +#644 = DEFINITIONAL_REPRESENTATION('',(#645),#649); +#645 = LINE('',#646,#647); +#646 = CARTESIAN_POINT('',(0.,-0.)); +#647 = VECTOR('',#648,1.); +#648 = DIRECTION('',(1.,0.)); +#649 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#650 = ORIENTED_EDGE('',*,*,#651,.T.); +#651 = EDGE_CURVE('',#624,#652,#654,.T.); +#652 = VERTEX_POINT('',#653); +#653 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#654 = SURFACE_CURVE('',#655,(#660,#667),.PCURVE_S1.); +#655 = CIRCLE('',#656,2.999999998497); +#656 = AXIS2_PLACEMENT_3D('',#657,#658,#659); +#657 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,0.)); +#658 = DIRECTION('',(0.,0.,-1.)); +#659 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#660 = PCURVE('',#160,#661); +#661 = DEFINITIONAL_REPRESENTATION('',(#662),#666); +#662 = CIRCLE('',#663,2.999999998497); +#663 = AXIS2_PLACEMENT_2D('',#664,#665); +#664 = CARTESIAN_POINT('',(11.342082057678,-61.60000000158)); +#665 = DIRECTION('',(-5.011600026375E-10,-1.)); +#666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#667 = PCURVE('',#668,#673); +#668 = CYLINDRICAL_SURFACE('',#669,2.999999998497); +#669 = AXIS2_PLACEMENT_3D('',#670,#671,#672); +#670 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,0.)); +#671 = DIRECTION('',(0.,0.,-1.)); +#672 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#673 = DEFINITIONAL_REPRESENTATION('',(#674),#678); +#674 = LINE('',#675,#676); +#675 = CARTESIAN_POINT('',(0.,0.)); +#676 = VECTOR('',#677,1.); +#677 = DIRECTION('',(1.,0.)); +#678 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#679 = ORIENTED_EDGE('',*,*,#680,.T.); +#680 = EDGE_CURVE('',#652,#681,#683,.T.); +#681 = VERTEX_POINT('',#682); +#682 = CARTESIAN_POINT('',(-33.,-41.6,0.)); +#683 = SURFACE_CURVE('',#684,(#688,#695),.PCURVE_S1.); +#684 = LINE('',#685,#686); +#685 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#686 = VECTOR('',#687,1.); +#687 = DIRECTION('',(0.,1.,0.)); +#688 = PCURVE('',#160,#689); +#689 = DEFINITIONAL_REPRESENTATION('',(#690),#694); +#690 = LINE('',#691,#692); +#691 = CARTESIAN_POINT('',(14.342082056175,-61.60000000008)); +#692 = VECTOR('',#693,1.); +#693 = DIRECTION('',(0.,1.)); +#694 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#695 = PCURVE('',#696,#701); +#696 = PLANE('',#697); +#697 = AXIS2_PLACEMENT_3D('',#698,#699,#700); +#698 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#699 = DIRECTION('',(-1.,0.,0.)); +#700 = DIRECTION('',(0.,1.,0.)); +#701 = DEFINITIONAL_REPRESENTATION('',(#702),#706); +#702 = LINE('',#703,#704); +#703 = CARTESIAN_POINT('',(0.,0.)); +#704 = VECTOR('',#705,1.); +#705 = DIRECTION('',(1.,0.)); +#706 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#707 = ORIENTED_EDGE('',*,*,#708,.T.); +#708 = EDGE_CURVE('',#681,#709,#711,.T.); +#709 = VERTEX_POINT('',#710); +#710 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#711 = SURFACE_CURVE('',#712,(#717,#724),.PCURVE_S1.); +#712 = CIRCLE('',#713,2.999999998497); +#713 = AXIS2_PLACEMENT_3D('',#714,#715,#716); +#714 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,0.)); +#715 = DIRECTION('',(0.,0.,-1.)); +#716 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#717 = PCURVE('',#160,#718); +#718 = DEFINITIONAL_REPRESENTATION('',(#719),#723); +#719 = CIRCLE('',#720,2.999999998497); +#720 = AXIS2_PLACEMENT_2D('',#721,#722); +#721 = CARTESIAN_POINT('',(11.342082057678,-41.59999999858)); +#722 = DIRECTION('',(1.,-5.011600026375E-10)); +#723 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#724 = PCURVE('',#725,#730); +#725 = CYLINDRICAL_SURFACE('',#726,2.999999998497); +#726 = AXIS2_PLACEMENT_3D('',#727,#728,#729); +#727 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,0.)); +#728 = DIRECTION('',(0.,0.,-1.)); +#729 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#730 = DEFINITIONAL_REPRESENTATION('',(#731),#735); +#731 = LINE('',#732,#733); +#732 = CARTESIAN_POINT('',(0.,0.)); +#733 = VECTOR('',#734,1.); +#734 = DIRECTION('',(1.,0.)); +#735 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#736 = ORIENTED_EDGE('',*,*,#737,.T.); +#737 = EDGE_CURVE('',#709,#738,#740,.T.); +#738 = VERTEX_POINT('',#739); +#739 = CARTESIAN_POINT('',(-24.,-38.6,0.)); +#740 = SURFACE_CURVE('',#741,(#745,#752),.PCURVE_S1.); +#741 = LINE('',#742,#743); +#742 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#743 = VECTOR('',#744,1.); +#744 = DIRECTION('',(1.,0.,0.)); +#745 = PCURVE('',#160,#746); +#746 = DEFINITIONAL_REPRESENTATION('',(#747),#751); +#747 = LINE('',#748,#749); +#748 = CARTESIAN_POINT('',(11.342082056175,-38.60000000008)); +#749 = VECTOR('',#750,1.); +#750 = DIRECTION('',(-1.,0.)); +#751 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#752 = PCURVE('',#753,#758); +#753 = PLANE('',#754); +#754 = AXIS2_PLACEMENT_3D('',#755,#756,#757); +#755 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#756 = DIRECTION('',(0.,1.,0.)); +#757 = DIRECTION('',(1.,0.,0.)); +#758 = DEFINITIONAL_REPRESENTATION('',(#759),#763); +#759 = LINE('',#760,#761); +#760 = CARTESIAN_POINT('',(0.,0.)); +#761 = VECTOR('',#762,1.); +#762 = DIRECTION('',(1.,0.)); +#763 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#764 = ORIENTED_EDGE('',*,*,#765,.T.); +#765 = EDGE_CURVE('',#738,#766,#768,.T.); +#766 = VERTEX_POINT('',#767); +#767 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#768 = SURFACE_CURVE('',#769,(#774,#785),.PCURVE_S1.); +#769 = CIRCLE('',#770,1.000000000637); +#770 = AXIS2_PLACEMENT_3D('',#771,#772,#773); +#771 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,0.)); +#772 = DIRECTION('',(0.,0.,1.)); +#773 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#774 = PCURVE('',#160,#775); +#775 = DEFINITIONAL_REPRESENTATION('',(#776),#784); +#776 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#777,#778,#779,#780,#781,#782 +,#783),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#777 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#778 = CARTESIAN_POINT('',(3.610031247503,-38.59999999898)); +#779 = CARTESIAN_POINT('',(4.476056652794,-37.09999999857)); +#780 = CARTESIAN_POINT('',(5.342082058085,-35.59999999817)); +#781 = CARTESIAN_POINT('',(6.208107461466,-37.09999999968)); +#782 = CARTESIAN_POINT('',(7.074132864847,-38.60000000118)); +#783 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#784 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#785 = PCURVE('',#786,#791); +#786 = CYLINDRICAL_SURFACE('',#787,1.000000000637); +#787 = AXIS2_PLACEMENT_3D('',#788,#789,#790); +#788 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,0.)); +#789 = DIRECTION('',(-0.,-0.,-1.)); +#790 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#791 = DEFINITIONAL_REPRESENTATION('',(#792),#796); +#792 = LINE('',#793,#794); +#793 = CARTESIAN_POINT('',(-0.,0.)); +#794 = VECTOR('',#795,1.); +#795 = DIRECTION('',(-1.,0.)); +#796 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#797 = ORIENTED_EDGE('',*,*,#798,.T.); +#798 = EDGE_CURVE('',#766,#799,#801,.T.); +#799 = VERTEX_POINT('',#800); +#800 = CARTESIAN_POINT('',(-23.,-36.6,0.)); +#801 = SURFACE_CURVE('',#802,(#806,#813),.PCURVE_S1.); +#802 = LINE('',#803,#804); +#803 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#804 = VECTOR('',#805,1.); +#805 = DIRECTION('',(0.,1.,0.)); +#806 = PCURVE('',#160,#807); +#807 = DEFINITIONAL_REPRESENTATION('',(#808),#812); +#808 = LINE('',#809,#810); +#809 = CARTESIAN_POINT('',(4.342082056175,-37.60000000008)); +#810 = VECTOR('',#811,1.); +#811 = DIRECTION('',(0.,1.)); +#812 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#813 = PCURVE('',#814,#819); +#814 = PLANE('',#815); +#815 = AXIS2_PLACEMENT_3D('',#816,#817,#818); +#816 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#817 = DIRECTION('',(-1.,0.,0.)); +#818 = DIRECTION('',(0.,1.,0.)); +#819 = DEFINITIONAL_REPRESENTATION('',(#820),#824); +#820 = LINE('',#821,#822); +#821 = CARTESIAN_POINT('',(0.,0.)); +#822 = VECTOR('',#823,1.); +#823 = DIRECTION('',(1.,0.)); +#824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#825 = ORIENTED_EDGE('',*,*,#826,.T.); +#826 = EDGE_CURVE('',#799,#827,#829,.T.); +#827 = VERTEX_POINT('',#828); +#828 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#829 = SURFACE_CURVE('',#830,(#835,#846),.PCURVE_S1.); +#830 = CIRCLE('',#831,1.000000000637); +#831 = AXIS2_PLACEMENT_3D('',#832,#833,#834); +#832 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,0.)); +#833 = DIRECTION('',(0.,0.,1.)); +#834 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#835 = PCURVE('',#160,#836); +#836 = DEFINITIONAL_REPRESENTATION('',(#837),#845); +#837 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#838,#839,#840,#841,#842,#843 +,#844),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#838 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#839 = CARTESIAN_POINT('',(4.342082057278,-34.86794919141)); +#840 = CARTESIAN_POINT('',(5.842082057682,-35.7339745967)); +#841 = CARTESIAN_POINT('',(7.342082058085,-36.60000000199)); +#842 = CARTESIAN_POINT('',(5.842082056578,-37.46602540537)); +#843 = CARTESIAN_POINT('',(4.342082055072,-38.33205080875)); +#844 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#845 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#846 = PCURVE('',#847,#852); +#847 = CYLINDRICAL_SURFACE('',#848,1.000000000637); +#848 = AXIS2_PLACEMENT_3D('',#849,#850,#851); +#849 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,0.)); +#850 = DIRECTION('',(-0.,-0.,-1.)); +#851 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#852 = DEFINITIONAL_REPRESENTATION('',(#853),#857); +#853 = LINE('',#854,#855); +#854 = CARTESIAN_POINT('',(-0.,0.)); +#855 = VECTOR('',#856,1.); +#856 = DIRECTION('',(-1.,0.)); +#857 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#858 = ORIENTED_EDGE('',*,*,#859,.T.); +#859 = EDGE_CURVE('',#827,#176,#860,.T.); +#860 = SURFACE_CURVE('',#861,(#865,#872),.PCURVE_S1.); +#861 = LINE('',#862,#863); +#862 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#863 = VECTOR('',#864,1.); +#864 = DIRECTION('',(-1.,0.,0.)); +#865 = PCURVE('',#160,#866); +#866 = DEFINITIONAL_REPRESENTATION('',(#867),#871); +#867 = LINE('',#868,#869); +#868 = CARTESIAN_POINT('',(5.342082056175,-35.60000000008)); +#869 = VECTOR('',#870,1.); +#870 = DIRECTION('',(1.,0.)); +#871 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#872 = PCURVE('',#193,#873); +#873 = DEFINITIONAL_REPRESENTATION('',(#874),#878); +#874 = LINE('',#875,#876); +#875 = CARTESIAN_POINT('',(0.,-0.)); +#876 = VECTOR('',#877,1.); +#877 = DIRECTION('',(1.,0.)); +#878 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#879 = ORIENTED_EDGE('',*,*,#227,.T.); +#880 = FACE_BOUND('',#881,.T.); +#881 = EDGE_LOOP('',(#882)); +#882 = ORIENTED_EDGE('',*,*,#883,.T.); +#883 = EDGE_CURVE('',#884,#884,#886,.T.); +#884 = VERTEX_POINT('',#885); +#885 = CARTESIAN_POINT('',(28.15,-61.6,0.)); +#886 = SURFACE_CURVE('',#887,(#892,#903),.PCURVE_S1.); +#887 = CIRCLE('',#888,2.15); +#888 = AXIS2_PLACEMENT_3D('',#889,#890,#891); +#889 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#890 = DIRECTION('',(0.,0.,1.)); +#891 = DIRECTION('',(1.,0.,0.)); +#892 = PCURVE('',#160,#893); +#893 = DEFINITIONAL_REPRESENTATION('',(#894),#902); +#894 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#895,#896,#897,#898,#899,#900 +,#901),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#895 = CARTESIAN_POINT('',(-46.80791794382,-61.60000000008)); +#896 = CARTESIAN_POINT('',(-46.80791794382,-57.87609076381)); +#897 = CARTESIAN_POINT('',(-43.58291794382,-59.73804538194)); +#898 = CARTESIAN_POINT('',(-40.35791794382,-61.60000000008)); +#899 = CARTESIAN_POINT('',(-43.58291794382,-63.46195461822)); +#900 = CARTESIAN_POINT('',(-46.80791794382,-65.32390923635)); +#901 = CARTESIAN_POINT('',(-46.80791794382,-61.60000000008)); +#902 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#903 = PCURVE('',#904,#909); +#904 = CYLINDRICAL_SURFACE('',#905,2.15); +#905 = AXIS2_PLACEMENT_3D('',#906,#907,#908); +#906 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#907 = DIRECTION('',(-0.,-0.,-1.)); +#908 = DIRECTION('',(1.,0.,0.)); +#909 = DEFINITIONAL_REPRESENTATION('',(#910),#914); +#910 = LINE('',#911,#912); +#911 = CARTESIAN_POINT('',(-0.,0.)); +#912 = VECTOR('',#913,1.); +#913 = DIRECTION('',(-1.,0.)); +#914 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#915 = FACE_BOUND('',#916,.T.); +#916 = EDGE_LOOP('',(#917)); +#917 = ORIENTED_EDGE('',*,*,#918,.T.); +#918 = EDGE_CURVE('',#919,#919,#921,.T.); +#919 = VERTEX_POINT('',#920); +#920 = CARTESIAN_POINT('',(-27.85,-61.6,0.)); +#921 = SURFACE_CURVE('',#922,(#927,#938),.PCURVE_S1.); +#922 = CIRCLE('',#923,2.15); +#923 = AXIS2_PLACEMENT_3D('',#924,#925,#926); +#924 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#925 = DIRECTION('',(0.,0.,1.)); +#926 = DIRECTION('',(1.,0.,0.)); +#927 = PCURVE('',#160,#928); +#928 = DEFINITIONAL_REPRESENTATION('',(#929),#937); +#929 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#930,#931,#932,#933,#934,#935 +,#936),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#930 = CARTESIAN_POINT('',(9.192082056175,-61.60000000008)); +#931 = CARTESIAN_POINT('',(9.192082056175,-57.87609076381)); +#932 = CARTESIAN_POINT('',(12.417082056175,-59.73804538194)); +#933 = CARTESIAN_POINT('',(15.642082056175,-61.60000000008)); +#934 = CARTESIAN_POINT('',(12.417082056175,-63.46195461822)); +#935 = CARTESIAN_POINT('',(9.192082056175,-65.32390923635)); +#936 = CARTESIAN_POINT('',(9.192082056175,-61.60000000008)); +#937 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#938 = PCURVE('',#939,#944); +#939 = CYLINDRICAL_SURFACE('',#940,2.15); +#940 = AXIS2_PLACEMENT_3D('',#941,#942,#943); +#941 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#942 = DIRECTION('',(-0.,-0.,-1.)); +#943 = DIRECTION('',(1.,0.,0.)); +#944 = DEFINITIONAL_REPRESENTATION('',(#945),#949); +#945 = LINE('',#946,#947); +#946 = CARTESIAN_POINT('',(-0.,0.)); +#947 = VECTOR('',#948,1.); +#948 = DIRECTION('',(-1.,0.)); +#949 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#950 = FACE_BOUND('',#951,.T.); +#951 = EDGE_LOOP('',(#952)); +#952 = ORIENTED_EDGE('',*,*,#953,.T.); +#953 = EDGE_CURVE('',#954,#954,#956,.T.); +#954 = VERTEX_POINT('',#955); +#955 = CARTESIAN_POINT('',(28.15,61.6,0.)); +#956 = SURFACE_CURVE('',#957,(#962,#973),.PCURVE_S1.); +#957 = CIRCLE('',#958,2.15); +#958 = AXIS2_PLACEMENT_3D('',#959,#960,#961); +#959 = CARTESIAN_POINT('',(26.,61.6,0.)); +#960 = DIRECTION('',(0.,0.,1.)); +#961 = DIRECTION('',(1.,0.,0.)); +#962 = PCURVE('',#160,#963); +#963 = DEFINITIONAL_REPRESENTATION('',(#964),#972); +#964 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#965,#966,#967,#968,#969,#970 +,#971),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#965 = CARTESIAN_POINT('',(-46.80791794382,61.599999999915)); +#966 = CARTESIAN_POINT('',(-46.80791794382,65.323909236188)); +#967 = CARTESIAN_POINT('',(-43.58291794382,63.461954618051)); +#968 = CARTESIAN_POINT('',(-40.35791794382,61.599999999915)); +#969 = CARTESIAN_POINT('',(-43.58291794382,59.738045381778)); +#970 = CARTESIAN_POINT('',(-46.80791794382,57.876090763642)); +#971 = CARTESIAN_POINT('',(-46.80791794382,61.599999999915)); +#972 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#973 = PCURVE('',#974,#979); +#974 = CYLINDRICAL_SURFACE('',#975,2.15); +#975 = AXIS2_PLACEMENT_3D('',#976,#977,#978); +#976 = CARTESIAN_POINT('',(26.,61.6,0.)); +#977 = DIRECTION('',(-0.,-0.,-1.)); +#978 = DIRECTION('',(1.,0.,0.)); +#979 = DEFINITIONAL_REPRESENTATION('',(#980),#984); +#980 = LINE('',#981,#982); +#981 = CARTESIAN_POINT('',(-0.,0.)); +#982 = VECTOR('',#983,1.); +#983 = DIRECTION('',(-1.,0.)); +#984 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#985 = FACE_BOUND('',#986,.T.); +#986 = EDGE_LOOP('',(#987)); +#987 = ORIENTED_EDGE('',*,*,#988,.T.); +#988 = EDGE_CURVE('',#989,#989,#991,.T.); +#989 = VERTEX_POINT('',#990); +#990 = CARTESIAN_POINT('',(-27.85,61.6,0.)); +#991 = SURFACE_CURVE('',#992,(#997,#1008),.PCURVE_S1.); +#992 = CIRCLE('',#993,2.15); +#993 = AXIS2_PLACEMENT_3D('',#994,#995,#996); +#994 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#995 = DIRECTION('',(0.,0.,1.)); +#996 = DIRECTION('',(1.,0.,0.)); +#997 = PCURVE('',#160,#998); +#998 = DEFINITIONAL_REPRESENTATION('',(#999),#1007); +#999 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1000,#1001,#1002,#1003,#1004 +,#1005,#1006),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2, + 2,1),(-2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718 +,8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#1000 = CARTESIAN_POINT('',(9.192082056175,61.599999999915)); +#1001 = CARTESIAN_POINT('',(9.192082056175,65.323909236188)); +#1002 = CARTESIAN_POINT('',(12.417082056175,63.461954618051)); +#1003 = CARTESIAN_POINT('',(15.642082056175,61.599999999915)); +#1004 = CARTESIAN_POINT('',(12.417082056175,59.738045381778)); +#1005 = CARTESIAN_POINT('',(9.192082056175,57.876090763642)); +#1006 = CARTESIAN_POINT('',(9.192082056175,61.599999999915)); +#1007 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1008 = PCURVE('',#1009,#1014); +#1009 = CYLINDRICAL_SURFACE('',#1010,2.15); +#1010 = AXIS2_PLACEMENT_3D('',#1011,#1012,#1013); +#1011 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#1012 = DIRECTION('',(-0.,-0.,-1.)); +#1013 = DIRECTION('',(1.,0.,0.)); +#1014 = DEFINITIONAL_REPRESENTATION('',(#1015),#1019); +#1015 = LINE('',#1016,#1017); +#1016 = CARTESIAN_POINT('',(-0.,0.)); +#1017 = VECTOR('',#1018,1.); +#1018 = DIRECTION('',(-1.,0.)); +#1019 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1020 = ADVANCED_FACE('',(#1021,#1482,#1517,#1552,#1587),#106,.F.); +#1021 = FACE_BOUND('',#1022,.F.); +#1022 = EDGE_LOOP('',(#1023,#1024,#1025,#1048,#1076,#1099,#1123,#1146, + #1170,#1193,#1217,#1240,#1264,#1287,#1311,#1334,#1358,#1381,#1409, + #1432,#1460,#1481)); +#1023 = ORIENTED_EDGE('',*,*,#90,.T.); +#1024 = ORIENTED_EDGE('',*,*,#252,.T.); +#1025 = ORIENTED_EDGE('',*,*,#1026,.T.); +#1026 = EDGE_CURVE('',#253,#1027,#1029,.T.); +#1027 = VERTEX_POINT('',#1028); +#1028 = CARTESIAN_POINT('',(-23.,37.6,4.5)); +#1029 = SURFACE_CURVE('',#1030,(#1034,#1041),.PCURVE_S1.); +#1030 = LINE('',#1031,#1032); +#1031 = CARTESIAN_POINT('',(-23.,36.6,4.5)); +#1032 = VECTOR('',#1033,1.); +#1033 = DIRECTION('',(0.,1.,0.)); +#1034 = PCURVE('',#106,#1035); +#1035 = DEFINITIONAL_REPRESENTATION('',(#1036),#1040); +#1036 = LINE('',#1037,#1038); +#1037 = CARTESIAN_POINT('',(4.342082056175,36.599999999915)); +#1038 = VECTOR('',#1039,1.); +#1039 = DIRECTION('',(0.,1.)); +#1040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1041 = PCURVE('',#296,#1042); +#1042 = DEFINITIONAL_REPRESENTATION('',(#1043),#1047); +#1043 = LINE('',#1044,#1045); +#1044 = CARTESIAN_POINT('',(0.,-4.5)); +#1045 = VECTOR('',#1046,1.); +#1046 = DIRECTION('',(1.,0.)); +#1047 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1048 = ORIENTED_EDGE('',*,*,#1049,.T.); +#1049 = EDGE_CURVE('',#1027,#1050,#1052,.T.); +#1050 = VERTEX_POINT('',#1051); +#1051 = CARTESIAN_POINT('',(-24.,38.6,4.5)); +#1052 = SURFACE_CURVE('',#1053,(#1058,#1069),.PCURVE_S1.); +#1053 = CIRCLE('',#1054,1.000000000637); +#1054 = AXIS2_PLACEMENT_3D('',#1055,#1056,#1057); +#1055 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,4.5)); +#1056 = DIRECTION('',(0.,0.,1.)); +#1057 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#1058 = PCURVE('',#106,#1059); +#1059 = DEFINITIONAL_REPRESENTATION('',(#1060),#1068); +#1060 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1061,#1062,#1063,#1064, +#1065,#1066,#1067),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1061 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#1062 = CARTESIAN_POINT('',(4.342082057278,39.332050808587)); +#1063 = CARTESIAN_POINT('',(5.842082057682,38.466025403295)); +#1064 = CARTESIAN_POINT('',(7.342082058085,37.599999998004)); +#1065 = CARTESIAN_POINT('',(5.842082056578,36.733974594623)); +#1066 = CARTESIAN_POINT('',(4.342082055072,35.867949191243)); +#1067 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#1068 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1069 = PCURVE('',#383,#1070); +#1070 = DEFINITIONAL_REPRESENTATION('',(#1071),#1075); +#1071 = LINE('',#1072,#1073); +#1072 = CARTESIAN_POINT('',(-0.,-4.5)); +#1073 = VECTOR('',#1074,1.); +#1074 = DIRECTION('',(-1.,0.)); +#1075 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1076 = ORIENTED_EDGE('',*,*,#1077,.T.); +#1077 = EDGE_CURVE('',#1050,#1078,#1080,.T.); +#1078 = VERTEX_POINT('',#1079); +#1079 = CARTESIAN_POINT('',(-30.,38.6,4.5)); +#1080 = SURFACE_CURVE('',#1081,(#1085,#1092),.PCURVE_S1.); +#1081 = LINE('',#1082,#1083); +#1082 = CARTESIAN_POINT('',(-24.,38.6,4.5)); +#1083 = VECTOR('',#1084,1.); +#1084 = DIRECTION('',(-1.,0.,0.)); +#1085 = PCURVE('',#106,#1086); +#1086 = DEFINITIONAL_REPRESENTATION('',(#1087),#1091); +#1087 = LINE('',#1088,#1089); +#1088 = CARTESIAN_POINT('',(5.342082056175,38.599999999915)); +#1089 = VECTOR('',#1090,1.); +#1090 = DIRECTION('',(1.,0.)); +#1091 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1092 = PCURVE('',#411,#1093); +#1093 = DEFINITIONAL_REPRESENTATION('',(#1094),#1098); +#1094 = LINE('',#1095,#1096); +#1095 = CARTESIAN_POINT('',(0.,-4.5)); +#1096 = VECTOR('',#1097,1.); +#1097 = DIRECTION('',(1.,0.)); +#1098 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1099 = ORIENTED_EDGE('',*,*,#1100,.T.); +#1100 = EDGE_CURVE('',#1078,#1101,#1103,.T.); +#1101 = VERTEX_POINT('',#1102); +#1102 = CARTESIAN_POINT('',(-33.,41.6,4.5)); +#1103 = SURFACE_CURVE('',#1104,(#1109,#1116),.PCURVE_S1.); +#1104 = CIRCLE('',#1105,2.999999998497); +#1105 = AXIS2_PLACEMENT_3D('',#1106,#1107,#1108); +#1106 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,4.5)); +#1107 = DIRECTION('',(0.,0.,-1.)); +#1108 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#1109 = PCURVE('',#106,#1110); +#1110 = DEFINITIONAL_REPRESENTATION('',(#1111),#1115); +#1111 = CIRCLE('',#1112,2.999999998497); +#1112 = AXIS2_PLACEMENT_2D('',#1113,#1114); +#1113 = CARTESIAN_POINT('',(11.342082057678,41.599999998411)); +#1114 = DIRECTION('',(-5.011588183996E-10,-1.)); +#1115 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1116 = PCURVE('',#440,#1117); +#1117 = DEFINITIONAL_REPRESENTATION('',(#1118),#1122); +#1118 = LINE('',#1119,#1120); +#1119 = CARTESIAN_POINT('',(0.,-4.5)); +#1120 = VECTOR('',#1121,1.); +#1121 = DIRECTION('',(1.,0.)); +#1122 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1123 = ORIENTED_EDGE('',*,*,#1124,.T.); +#1124 = EDGE_CURVE('',#1101,#1125,#1127,.T.); +#1125 = VERTEX_POINT('',#1126); +#1126 = CARTESIAN_POINT('',(-33.,61.6,4.5)); +#1127 = SURFACE_CURVE('',#1128,(#1132,#1139),.PCURVE_S1.); +#1128 = LINE('',#1129,#1130); +#1129 = CARTESIAN_POINT('',(-33.,41.6,4.5)); +#1130 = VECTOR('',#1131,1.); +#1131 = DIRECTION('',(0.,1.,0.)); +#1132 = PCURVE('',#106,#1133); +#1133 = DEFINITIONAL_REPRESENTATION('',(#1134),#1138); +#1134 = LINE('',#1135,#1136); +#1135 = CARTESIAN_POINT('',(14.342082056175,41.599999999915)); +#1136 = VECTOR('',#1137,1.); +#1137 = DIRECTION('',(0.,1.)); +#1138 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1139 = PCURVE('',#468,#1140); +#1140 = DEFINITIONAL_REPRESENTATION('',(#1141),#1145); +#1141 = LINE('',#1142,#1143); +#1142 = CARTESIAN_POINT('',(0.,-4.5)); +#1143 = VECTOR('',#1144,1.); +#1144 = DIRECTION('',(1.,0.)); +#1145 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1146 = ORIENTED_EDGE('',*,*,#1147,.T.); +#1147 = EDGE_CURVE('',#1125,#1148,#1150,.T.); +#1148 = VERTEX_POINT('',#1149); +#1149 = CARTESIAN_POINT('',(-30.,64.6,4.5)); +#1150 = SURFACE_CURVE('',#1151,(#1156,#1163),.PCURVE_S1.); +#1151 = CIRCLE('',#1152,2.999999998497); +#1152 = AXIS2_PLACEMENT_3D('',#1153,#1154,#1155); +#1153 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,4.5)); +#1154 = DIRECTION('',(0.,0.,-1.)); +#1155 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#1156 = PCURVE('',#106,#1157); +#1157 = DEFINITIONAL_REPRESENTATION('',(#1158),#1162); +#1158 = CIRCLE('',#1159,2.999999998497); +#1159 = AXIS2_PLACEMENT_2D('',#1160,#1161); +#1160 = CARTESIAN_POINT('',(11.342082057678,61.600000001418)); +#1161 = DIRECTION('',(1.,-5.011576341617E-10)); +#1162 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1163 = PCURVE('',#497,#1164); +#1164 = DEFINITIONAL_REPRESENTATION('',(#1165),#1169); +#1165 = LINE('',#1166,#1167); +#1166 = CARTESIAN_POINT('',(0.,-4.5)); +#1167 = VECTOR('',#1168,1.); +#1168 = DIRECTION('',(1.,0.)); +#1169 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1170 = ORIENTED_EDGE('',*,*,#1171,.T.); +#1171 = EDGE_CURVE('',#1148,#1172,#1174,.T.); +#1172 = VERTEX_POINT('',#1173); +#1173 = CARTESIAN_POINT('',(26.,64.6,4.5)); +#1174 = SURFACE_CURVE('',#1175,(#1179,#1186),.PCURVE_S1.); +#1175 = LINE('',#1176,#1177); +#1176 = CARTESIAN_POINT('',(-30.,64.6,4.5)); +#1177 = VECTOR('',#1178,1.); +#1178 = DIRECTION('',(1.,0.,0.)); +#1179 = PCURVE('',#106,#1180); +#1180 = DEFINITIONAL_REPRESENTATION('',(#1181),#1185); +#1181 = LINE('',#1182,#1183); +#1182 = CARTESIAN_POINT('',(11.342082056175,64.599999999915)); +#1183 = VECTOR('',#1184,1.); +#1184 = DIRECTION('',(-1.,0.)); +#1185 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1186 = PCURVE('',#525,#1187); +#1187 = DEFINITIONAL_REPRESENTATION('',(#1188),#1192); +#1188 = LINE('',#1189,#1190); +#1189 = CARTESIAN_POINT('',(0.,-4.5)); +#1190 = VECTOR('',#1191,1.); +#1191 = DIRECTION('',(1.,0.)); +#1192 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1193 = ORIENTED_EDGE('',*,*,#1194,.T.); +#1194 = EDGE_CURVE('',#1172,#1195,#1197,.T.); +#1195 = VERTEX_POINT('',#1196); +#1196 = CARTESIAN_POINT('',(29.,61.6,4.5)); +#1197 = SURFACE_CURVE('',#1198,(#1203,#1210),.PCURVE_S1.); +#1198 = CIRCLE('',#1199,2.999999998497); +#1199 = AXIS2_PLACEMENT_3D('',#1200,#1201,#1202); +#1200 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,4.5)); +#1201 = DIRECTION('',(0.,0.,-1.)); +#1202 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#1203 = PCURVE('',#106,#1204); +#1204 = DEFINITIONAL_REPRESENTATION('',(#1205),#1209); +#1205 = CIRCLE('',#1206,2.999999998497); +#1206 = AXIS2_PLACEMENT_2D('',#1207,#1208); +#1207 = CARTESIAN_POINT('',(-44.65791794532,61.600000001418)); +#1208 = DIRECTION('',(5.011611868754E-10,1.)); +#1209 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1210 = PCURVE('',#554,#1211); +#1211 = DEFINITIONAL_REPRESENTATION('',(#1212),#1216); +#1212 = LINE('',#1213,#1214); +#1213 = CARTESIAN_POINT('',(0.,-4.5)); +#1214 = VECTOR('',#1215,1.); +#1215 = DIRECTION('',(1.,0.)); +#1216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1217 = ORIENTED_EDGE('',*,*,#1218,.T.); +#1218 = EDGE_CURVE('',#1195,#1219,#1221,.T.); +#1219 = VERTEX_POINT('',#1220); +#1220 = CARTESIAN_POINT('',(29.,-61.6,4.5)); +#1221 = SURFACE_CURVE('',#1222,(#1226,#1233),.PCURVE_S1.); +#1222 = LINE('',#1223,#1224); +#1223 = CARTESIAN_POINT('',(29.,61.6,4.5)); +#1224 = VECTOR('',#1225,1.); +#1225 = DIRECTION('',(0.,-1.,0.)); +#1226 = PCURVE('',#106,#1227); +#1227 = DEFINITIONAL_REPRESENTATION('',(#1228),#1232); +#1228 = LINE('',#1229,#1230); +#1229 = CARTESIAN_POINT('',(-47.65791794382,61.599999999915)); +#1230 = VECTOR('',#1231,1.); +#1231 = DIRECTION('',(0.,-1.)); +#1232 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1233 = PCURVE('',#582,#1234); +#1234 = DEFINITIONAL_REPRESENTATION('',(#1235),#1239); +#1235 = LINE('',#1236,#1237); +#1236 = CARTESIAN_POINT('',(0.,-4.5)); +#1237 = VECTOR('',#1238,1.); +#1238 = DIRECTION('',(1.,0.)); +#1239 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1240 = ORIENTED_EDGE('',*,*,#1241,.T.); +#1241 = EDGE_CURVE('',#1219,#1242,#1244,.T.); +#1242 = VERTEX_POINT('',#1243); +#1243 = CARTESIAN_POINT('',(26.,-64.6,4.5)); +#1244 = SURFACE_CURVE('',#1245,(#1250,#1257),.PCURVE_S1.); +#1245 = CIRCLE('',#1246,3.000000000204); +#1246 = AXIS2_PLACEMENT_3D('',#1247,#1248,#1249); +#1247 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,4.5)); +#1248 = DIRECTION('',(0.,0.,-1.)); +#1249 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#1250 = PCURVE('',#106,#1251); +#1251 = DEFINITIONAL_REPRESENTATION('',(#1252),#1256); +#1252 = CIRCLE('',#1253,3.000000000204); +#1253 = AXIS2_PLACEMENT_2D('',#1254,#1255); +#1254 = CARTESIAN_POINT('',(-44.65791794362,-61.59999999988)); +#1255 = DIRECTION('',(-1.,-6.787814754256E-11)); +#1256 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1257 = PCURVE('',#611,#1258); +#1258 = DEFINITIONAL_REPRESENTATION('',(#1259),#1263); +#1259 = LINE('',#1260,#1261); +#1260 = CARTESIAN_POINT('',(0.,-4.5)); +#1261 = VECTOR('',#1262,1.); +#1262 = DIRECTION('',(1.,0.)); +#1263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1264 = ORIENTED_EDGE('',*,*,#1265,.T.); +#1265 = EDGE_CURVE('',#1242,#1266,#1268,.T.); +#1266 = VERTEX_POINT('',#1267); +#1267 = CARTESIAN_POINT('',(-30.,-64.6,4.5)); +#1268 = SURFACE_CURVE('',#1269,(#1273,#1280),.PCURVE_S1.); +#1269 = LINE('',#1270,#1271); +#1270 = CARTESIAN_POINT('',(26.,-64.6,4.5)); +#1271 = VECTOR('',#1272,1.); +#1272 = DIRECTION('',(-1.,0.,0.)); +#1273 = PCURVE('',#106,#1274); +#1274 = DEFINITIONAL_REPRESENTATION('',(#1275),#1279); +#1275 = LINE('',#1276,#1277); +#1276 = CARTESIAN_POINT('',(-44.65791794382,-64.60000000008)); +#1277 = VECTOR('',#1278,1.); +#1278 = DIRECTION('',(1.,0.)); +#1279 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1280 = PCURVE('',#639,#1281); +#1281 = DEFINITIONAL_REPRESENTATION('',(#1282),#1286); +#1282 = LINE('',#1283,#1284); +#1283 = CARTESIAN_POINT('',(0.,-4.5)); +#1284 = VECTOR('',#1285,1.); +#1285 = DIRECTION('',(1.,0.)); +#1286 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1287 = ORIENTED_EDGE('',*,*,#1288,.T.); +#1288 = EDGE_CURVE('',#1266,#1289,#1291,.T.); +#1289 = VERTEX_POINT('',#1290); +#1290 = CARTESIAN_POINT('',(-33.,-61.6,4.5)); +#1291 = SURFACE_CURVE('',#1292,(#1297,#1304),.PCURVE_S1.); +#1292 = CIRCLE('',#1293,2.999999998497); +#1293 = AXIS2_PLACEMENT_3D('',#1294,#1295,#1296); +#1294 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,4.5)); +#1295 = DIRECTION('',(0.,0.,-1.)); +#1296 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#1297 = PCURVE('',#106,#1298); +#1298 = DEFINITIONAL_REPRESENTATION('',(#1299),#1303); +#1299 = CIRCLE('',#1300,2.999999998497); +#1300 = AXIS2_PLACEMENT_2D('',#1301,#1302); +#1301 = CARTESIAN_POINT('',(11.342082057678,-61.60000000158)); +#1302 = DIRECTION('',(-5.011600026375E-10,-1.)); +#1303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1304 = PCURVE('',#668,#1305); +#1305 = DEFINITIONAL_REPRESENTATION('',(#1306),#1310); +#1306 = LINE('',#1307,#1308); +#1307 = CARTESIAN_POINT('',(0.,-4.5)); +#1308 = VECTOR('',#1309,1.); +#1309 = DIRECTION('',(1.,0.)); +#1310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1311 = ORIENTED_EDGE('',*,*,#1312,.T.); +#1312 = EDGE_CURVE('',#1289,#1313,#1315,.T.); +#1313 = VERTEX_POINT('',#1314); +#1314 = CARTESIAN_POINT('',(-33.,-41.6,4.5)); +#1315 = SURFACE_CURVE('',#1316,(#1320,#1327),.PCURVE_S1.); +#1316 = LINE('',#1317,#1318); +#1317 = CARTESIAN_POINT('',(-33.,-61.6,4.5)); +#1318 = VECTOR('',#1319,1.); +#1319 = DIRECTION('',(0.,1.,0.)); +#1320 = PCURVE('',#106,#1321); +#1321 = DEFINITIONAL_REPRESENTATION('',(#1322),#1326); +#1322 = LINE('',#1323,#1324); +#1323 = CARTESIAN_POINT('',(14.342082056175,-61.60000000008)); +#1324 = VECTOR('',#1325,1.); +#1325 = DIRECTION('',(0.,1.)); +#1326 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1327 = PCURVE('',#696,#1328); +#1328 = DEFINITIONAL_REPRESENTATION('',(#1329),#1333); +#1329 = LINE('',#1330,#1331); +#1330 = CARTESIAN_POINT('',(0.,-4.5)); +#1331 = VECTOR('',#1332,1.); +#1332 = DIRECTION('',(1.,0.)); +#1333 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1334 = ORIENTED_EDGE('',*,*,#1335,.T.); +#1335 = EDGE_CURVE('',#1313,#1336,#1338,.T.); +#1336 = VERTEX_POINT('',#1337); +#1337 = CARTESIAN_POINT('',(-30.,-38.6,4.5)); +#1338 = SURFACE_CURVE('',#1339,(#1344,#1351),.PCURVE_S1.); +#1339 = CIRCLE('',#1340,2.999999998497); +#1340 = AXIS2_PLACEMENT_3D('',#1341,#1342,#1343); +#1341 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,4.5)); +#1342 = DIRECTION('',(0.,0.,-1.)); +#1343 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#1344 = PCURVE('',#106,#1345); +#1345 = DEFINITIONAL_REPRESENTATION('',(#1346),#1350); +#1346 = CIRCLE('',#1347,2.999999998497); +#1347 = AXIS2_PLACEMENT_2D('',#1348,#1349); +#1348 = CARTESIAN_POINT('',(11.342082057678,-41.59999999858)); +#1349 = DIRECTION('',(1.,-5.011600026375E-10)); +#1350 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1351 = PCURVE('',#725,#1352); +#1352 = DEFINITIONAL_REPRESENTATION('',(#1353),#1357); +#1353 = LINE('',#1354,#1355); +#1354 = CARTESIAN_POINT('',(0.,-4.5)); +#1355 = VECTOR('',#1356,1.); +#1356 = DIRECTION('',(1.,0.)); +#1357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1358 = ORIENTED_EDGE('',*,*,#1359,.T.); +#1359 = EDGE_CURVE('',#1336,#1360,#1362,.T.); +#1360 = VERTEX_POINT('',#1361); +#1361 = CARTESIAN_POINT('',(-24.,-38.6,4.5)); +#1362 = SURFACE_CURVE('',#1363,(#1367,#1374),.PCURVE_S1.); +#1363 = LINE('',#1364,#1365); +#1364 = CARTESIAN_POINT('',(-30.,-38.6,4.5)); +#1365 = VECTOR('',#1366,1.); +#1366 = DIRECTION('',(1.,0.,0.)); +#1367 = PCURVE('',#106,#1368); +#1368 = DEFINITIONAL_REPRESENTATION('',(#1369),#1373); +#1369 = LINE('',#1370,#1371); +#1370 = CARTESIAN_POINT('',(11.342082056175,-38.60000000008)); +#1371 = VECTOR('',#1372,1.); +#1372 = DIRECTION('',(-1.,0.)); +#1373 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1374 = PCURVE('',#753,#1375); +#1375 = DEFINITIONAL_REPRESENTATION('',(#1376),#1380); +#1376 = LINE('',#1377,#1378); +#1377 = CARTESIAN_POINT('',(0.,-4.5)); +#1378 = VECTOR('',#1379,1.); +#1379 = DIRECTION('',(1.,0.)); +#1380 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1381 = ORIENTED_EDGE('',*,*,#1382,.T.); +#1382 = EDGE_CURVE('',#1360,#1383,#1385,.T.); +#1383 = VERTEX_POINT('',#1384); +#1384 = CARTESIAN_POINT('',(-23.,-37.6,4.5)); +#1385 = SURFACE_CURVE('',#1386,(#1391,#1402),.PCURVE_S1.); +#1386 = CIRCLE('',#1387,1.000000000637); +#1387 = AXIS2_PLACEMENT_3D('',#1388,#1389,#1390); +#1388 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,4.5)); +#1389 = DIRECTION('',(0.,0.,1.)); +#1390 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#1391 = PCURVE('',#106,#1392); +#1392 = DEFINITIONAL_REPRESENTATION('',(#1393),#1401); +#1393 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1394,#1395,#1396,#1397, +#1398,#1399,#1400),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1394 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#1395 = CARTESIAN_POINT('',(3.610031247503,-38.59999999898)); +#1396 = CARTESIAN_POINT('',(4.476056652794,-37.09999999857)); +#1397 = CARTESIAN_POINT('',(5.342082058085,-35.59999999817)); +#1398 = CARTESIAN_POINT('',(6.208107461466,-37.09999999968)); +#1399 = CARTESIAN_POINT('',(7.074132864847,-38.60000000118)); +#1400 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#1401 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1402 = PCURVE('',#786,#1403); +#1403 = DEFINITIONAL_REPRESENTATION('',(#1404),#1408); +#1404 = LINE('',#1405,#1406); +#1405 = CARTESIAN_POINT('',(-0.,-4.5)); +#1406 = VECTOR('',#1407,1.); +#1407 = DIRECTION('',(-1.,0.)); +#1408 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1409 = ORIENTED_EDGE('',*,*,#1410,.T.); +#1410 = EDGE_CURVE('',#1383,#1411,#1413,.T.); +#1411 = VERTEX_POINT('',#1412); +#1412 = CARTESIAN_POINT('',(-23.,-36.6,4.5)); +#1413 = SURFACE_CURVE('',#1414,(#1418,#1425),.PCURVE_S1.); +#1414 = LINE('',#1415,#1416); +#1415 = CARTESIAN_POINT('',(-23.,-37.6,4.5)); +#1416 = VECTOR('',#1417,1.); +#1417 = DIRECTION('',(0.,1.,0.)); +#1418 = PCURVE('',#106,#1419); +#1419 = DEFINITIONAL_REPRESENTATION('',(#1420),#1424); +#1420 = LINE('',#1421,#1422); +#1421 = CARTESIAN_POINT('',(4.342082056175,-37.60000000008)); +#1422 = VECTOR('',#1423,1.); +#1423 = DIRECTION('',(0.,1.)); +#1424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1425 = PCURVE('',#814,#1426); +#1426 = DEFINITIONAL_REPRESENTATION('',(#1427),#1431); +#1427 = LINE('',#1428,#1429); +#1428 = CARTESIAN_POINT('',(0.,-4.5)); +#1429 = VECTOR('',#1430,1.); +#1430 = DIRECTION('',(1.,0.)); +#1431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1432 = ORIENTED_EDGE('',*,*,#1433,.T.); +#1433 = EDGE_CURVE('',#1411,#1434,#1436,.T.); +#1434 = VERTEX_POINT('',#1435); +#1435 = CARTESIAN_POINT('',(-24.,-35.6,4.5)); +#1436 = SURFACE_CURVE('',#1437,(#1442,#1453),.PCURVE_S1.); +#1437 = CIRCLE('',#1438,1.000000000637); +#1438 = AXIS2_PLACEMENT_3D('',#1439,#1440,#1441); +#1439 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,4.5)); +#1440 = DIRECTION('',(0.,0.,1.)); +#1441 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#1442 = PCURVE('',#106,#1443); +#1443 = DEFINITIONAL_REPRESENTATION('',(#1444),#1452); +#1444 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1445,#1446,#1447,#1448, +#1449,#1450,#1451),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1445 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#1446 = CARTESIAN_POINT('',(4.342082057278,-34.86794919141)); +#1447 = CARTESIAN_POINT('',(5.842082057682,-35.7339745967)); +#1448 = CARTESIAN_POINT('',(7.342082058085,-36.60000000199)); +#1449 = CARTESIAN_POINT('',(5.842082056578,-37.46602540537)); +#1450 = CARTESIAN_POINT('',(4.342082055072,-38.33205080875)); +#1451 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#1452 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1453 = PCURVE('',#847,#1454); +#1454 = DEFINITIONAL_REPRESENTATION('',(#1455),#1459); +#1455 = LINE('',#1456,#1457); +#1456 = CARTESIAN_POINT('',(-0.,-4.5)); +#1457 = VECTOR('',#1458,1.); +#1458 = DIRECTION('',(-1.,0.)); +#1459 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1460 = ORIENTED_EDGE('',*,*,#1461,.T.); +#1461 = EDGE_CURVE('',#1434,#178,#1462,.T.); +#1462 = SURFACE_CURVE('',#1463,(#1467,#1474),.PCURVE_S1.); +#1463 = LINE('',#1464,#1465); +#1464 = CARTESIAN_POINT('',(-24.,-35.6,4.5)); +#1465 = VECTOR('',#1466,1.); +#1466 = DIRECTION('',(-1.,0.,0.)); +#1467 = PCURVE('',#106,#1468); +#1468 = DEFINITIONAL_REPRESENTATION('',(#1469),#1473); +#1469 = LINE('',#1470,#1471); +#1470 = CARTESIAN_POINT('',(5.342082056175,-35.60000000008)); +#1471 = VECTOR('',#1472,1.); +#1472 = DIRECTION('',(1.,0.)); +#1473 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1474 = PCURVE('',#193,#1475); +#1475 = DEFINITIONAL_REPRESENTATION('',(#1476),#1480); +#1476 = LINE('',#1477,#1478); +#1477 = CARTESIAN_POINT('',(0.,-4.5)); +#1478 = VECTOR('',#1479,1.); +#1479 = DIRECTION('',(1.,0.)); +#1480 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1481 = ORIENTED_EDGE('',*,*,#205,.T.); +#1482 = FACE_BOUND('',#1483,.F.); +#1483 = EDGE_LOOP('',(#1484)); +#1484 = ORIENTED_EDGE('',*,*,#1485,.T.); +#1485 = EDGE_CURVE('',#1486,#1486,#1488,.T.); +#1486 = VERTEX_POINT('',#1487); +#1487 = CARTESIAN_POINT('',(27.15,-61.6,4.5)); +#1488 = SURFACE_CURVE('',#1489,(#1494,#1505),.PCURVE_S1.); +#1489 = CIRCLE('',#1490,1.15); +#1490 = AXIS2_PLACEMENT_3D('',#1491,#1492,#1493); +#1491 = CARTESIAN_POINT('',(26.,-61.6,4.5)); +#1492 = DIRECTION('',(0.,0.,1.)); +#1493 = DIRECTION('',(1.,0.,0.)); +#1494 = PCURVE('',#106,#1495); +#1495 = DEFINITIONAL_REPRESENTATION('',(#1496),#1504); +#1496 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1497,#1498,#1499,#1500, +#1501,#1502,#1503),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1497 = CARTESIAN_POINT('',(-45.80791794382,-61.60000000008)); +#1498 = CARTESIAN_POINT('',(-45.80791794382,-59.60814157138)); +#1499 = CARTESIAN_POINT('',(-44.08291794382,-60.60407078573)); +#1500 = CARTESIAN_POINT('',(-42.35791794382,-61.60000000008)); +#1501 = CARTESIAN_POINT('',(-44.08291794382,-62.59592921443)); +#1502 = CARTESIAN_POINT('',(-45.80791794382,-63.59185842879)); +#1503 = CARTESIAN_POINT('',(-45.80791794382,-61.60000000008)); +#1504 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1505 = PCURVE('',#1506,#1511); +#1506 = CYLINDRICAL_SURFACE('',#1507,1.15); +#1507 = AXIS2_PLACEMENT_3D('',#1508,#1509,#1510); +#1508 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#1509 = DIRECTION('',(-0.,-0.,-1.)); +#1510 = DIRECTION('',(1.,0.,0.)); +#1511 = DEFINITIONAL_REPRESENTATION('',(#1512),#1516); +#1512 = LINE('',#1513,#1514); +#1513 = CARTESIAN_POINT('',(-0.,-4.5)); +#1514 = VECTOR('',#1515,1.); +#1515 = DIRECTION('',(-1.,0.)); +#1516 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1517 = FACE_BOUND('',#1518,.F.); +#1518 = EDGE_LOOP('',(#1519)); +#1519 = ORIENTED_EDGE('',*,*,#1520,.T.); +#1520 = EDGE_CURVE('',#1521,#1521,#1523,.T.); +#1521 = VERTEX_POINT('',#1522); +#1522 = CARTESIAN_POINT('',(-28.85,-61.6,4.5)); +#1523 = SURFACE_CURVE('',#1524,(#1529,#1540),.PCURVE_S1.); +#1524 = CIRCLE('',#1525,1.15); +#1525 = AXIS2_PLACEMENT_3D('',#1526,#1527,#1528); +#1526 = CARTESIAN_POINT('',(-30.,-61.6,4.5)); +#1527 = DIRECTION('',(0.,0.,1.)); +#1528 = DIRECTION('',(1.,0.,0.)); +#1529 = PCURVE('',#106,#1530); +#1530 = DEFINITIONAL_REPRESENTATION('',(#1531),#1539); +#1531 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1532,#1533,#1534,#1535, +#1536,#1537,#1538),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1532 = CARTESIAN_POINT('',(10.192082056175,-61.60000000008)); +#1533 = CARTESIAN_POINT('',(10.192082056175,-59.60814157138)); +#1534 = CARTESIAN_POINT('',(11.917082056175,-60.60407078573)); +#1535 = CARTESIAN_POINT('',(13.642082056175,-61.60000000008)); +#1536 = CARTESIAN_POINT('',(11.917082056175,-62.59592921443)); +#1537 = CARTESIAN_POINT('',(10.192082056175,-63.59185842879)); +#1538 = CARTESIAN_POINT('',(10.192082056175,-61.60000000008)); +#1539 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1540 = PCURVE('',#1541,#1546); +#1541 = CYLINDRICAL_SURFACE('',#1542,1.15); +#1542 = AXIS2_PLACEMENT_3D('',#1543,#1544,#1545); +#1543 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#1544 = DIRECTION('',(-0.,-0.,-1.)); +#1545 = DIRECTION('',(1.,0.,0.)); +#1546 = DEFINITIONAL_REPRESENTATION('',(#1547),#1551); +#1547 = LINE('',#1548,#1549); +#1548 = CARTESIAN_POINT('',(-0.,-4.5)); +#1549 = VECTOR('',#1550,1.); +#1550 = DIRECTION('',(-1.,0.)); +#1551 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1552 = FACE_BOUND('',#1553,.F.); +#1553 = EDGE_LOOP('',(#1554)); +#1554 = ORIENTED_EDGE('',*,*,#1555,.T.); +#1555 = EDGE_CURVE('',#1556,#1556,#1558,.T.); +#1556 = VERTEX_POINT('',#1557); +#1557 = CARTESIAN_POINT('',(27.15,61.6,4.5)); +#1558 = SURFACE_CURVE('',#1559,(#1564,#1575),.PCURVE_S1.); +#1559 = CIRCLE('',#1560,1.15); +#1560 = AXIS2_PLACEMENT_3D('',#1561,#1562,#1563); +#1561 = CARTESIAN_POINT('',(26.,61.6,4.5)); +#1562 = DIRECTION('',(0.,0.,1.)); +#1563 = DIRECTION('',(1.,0.,0.)); +#1564 = PCURVE('',#106,#1565); +#1565 = DEFINITIONAL_REPRESENTATION('',(#1566),#1574); +#1566 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1567,#1568,#1569,#1570, +#1571,#1572,#1573),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1567 = CARTESIAN_POINT('',(-45.80791794382,61.599999999915)); +#1568 = CARTESIAN_POINT('',(-45.80791794382,63.591858428619)); +#1569 = CARTESIAN_POINT('',(-44.08291794382,62.595929214267)); +#1570 = CARTESIAN_POINT('',(-42.35791794382,61.599999999915)); +#1571 = CARTESIAN_POINT('',(-44.08291794382,60.604070785563)); +#1572 = CARTESIAN_POINT('',(-45.80791794382,59.60814157121)); +#1573 = CARTESIAN_POINT('',(-45.80791794382,61.599999999915)); +#1574 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1575 = PCURVE('',#1576,#1581); +#1576 = CYLINDRICAL_SURFACE('',#1577,1.15); +#1577 = AXIS2_PLACEMENT_3D('',#1578,#1579,#1580); +#1578 = CARTESIAN_POINT('',(26.,61.6,0.)); +#1579 = DIRECTION('',(-0.,-0.,-1.)); +#1580 = DIRECTION('',(1.,0.,0.)); +#1581 = DEFINITIONAL_REPRESENTATION('',(#1582),#1586); +#1582 = LINE('',#1583,#1584); +#1583 = CARTESIAN_POINT('',(-0.,-4.5)); +#1584 = VECTOR('',#1585,1.); +#1585 = DIRECTION('',(-1.,0.)); +#1586 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1587 = FACE_BOUND('',#1588,.F.); +#1588 = EDGE_LOOP('',(#1589)); +#1589 = ORIENTED_EDGE('',*,*,#1590,.T.); +#1590 = EDGE_CURVE('',#1591,#1591,#1593,.T.); +#1591 = VERTEX_POINT('',#1592); +#1592 = CARTESIAN_POINT('',(-28.85,61.6,4.5)); +#1593 = SURFACE_CURVE('',#1594,(#1599,#1610),.PCURVE_S1.); +#1594 = CIRCLE('',#1595,1.15); +#1595 = AXIS2_PLACEMENT_3D('',#1596,#1597,#1598); +#1596 = CARTESIAN_POINT('',(-30.,61.6,4.5)); +#1597 = DIRECTION('',(0.,0.,1.)); +#1598 = DIRECTION('',(1.,0.,0.)); +#1599 = PCURVE('',#106,#1600); +#1600 = DEFINITIONAL_REPRESENTATION('',(#1601),#1609); +#1601 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1602,#1603,#1604,#1605, +#1606,#1607,#1608),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1602 = CARTESIAN_POINT('',(10.192082056175,61.599999999915)); +#1603 = CARTESIAN_POINT('',(10.192082056175,63.591858428619)); +#1604 = CARTESIAN_POINT('',(11.917082056175,62.595929214267)); +#1605 = CARTESIAN_POINT('',(13.642082056175,61.599999999915)); +#1606 = CARTESIAN_POINT('',(11.917082056175,60.604070785563)); +#1607 = CARTESIAN_POINT('',(10.192082056175,59.60814157121)); +#1608 = CARTESIAN_POINT('',(10.192082056175,61.599999999915)); +#1609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1610 = PCURVE('',#1611,#1616); +#1611 = CYLINDRICAL_SURFACE('',#1612,1.15); +#1612 = AXIS2_PLACEMENT_3D('',#1613,#1614,#1615); +#1613 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#1614 = DIRECTION('',(-0.,-0.,-1.)); +#1615 = DIRECTION('',(1.,0.,0.)); +#1616 = DEFINITIONAL_REPRESENTATION('',(#1617),#1621); +#1617 = LINE('',#1618,#1619); +#1618 = CARTESIAN_POINT('',(-0.,-4.5)); +#1619 = VECTOR('',#1620,1.); +#1620 = DIRECTION('',(-1.,0.)); +#1621 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1622 = ADVANCED_FACE('',(#1623),#193,.T.); +#1623 = FACE_BOUND('',#1624,.T.); +#1624 = EDGE_LOOP('',(#1625,#1646,#1647,#1648)); +#1625 = ORIENTED_EDGE('',*,*,#1626,.T.); +#1626 = EDGE_CURVE('',#827,#1434,#1627,.T.); +#1627 = SURFACE_CURVE('',#1628,(#1632,#1639),.PCURVE_S1.); +#1628 = LINE('',#1629,#1630); +#1629 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#1630 = VECTOR('',#1631,1.); +#1631 = DIRECTION('',(0.,0.,1.)); +#1632 = PCURVE('',#193,#1633); +#1633 = DEFINITIONAL_REPRESENTATION('',(#1634),#1638); +#1634 = LINE('',#1635,#1636); +#1635 = CARTESIAN_POINT('',(0.,-0.)); +#1636 = VECTOR('',#1637,1.); +#1637 = DIRECTION('',(0.,-1.)); +#1638 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1639 = PCURVE('',#847,#1640); +#1640 = DEFINITIONAL_REPRESENTATION('',(#1641),#1645); +#1641 = LINE('',#1642,#1643); +#1642 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1643 = VECTOR('',#1644,1.); +#1644 = DIRECTION('',(-0.,-1.)); +#1645 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1646 = ORIENTED_EDGE('',*,*,#1461,.T.); +#1647 = ORIENTED_EDGE('',*,*,#175,.F.); +#1648 = ORIENTED_EDGE('',*,*,#859,.F.); +#1649 = ADVANCED_FACE('',(#1650),#296,.T.); +#1650 = FACE_BOUND('',#1651,.T.); +#1651 = EDGE_LOOP('',(#1652,#1653,#1654,#1675)); +#1652 = ORIENTED_EDGE('',*,*,#280,.T.); +#1653 = ORIENTED_EDGE('',*,*,#1026,.T.); +#1654 = ORIENTED_EDGE('',*,*,#1655,.F.); +#1655 = EDGE_CURVE('',#340,#1027,#1656,.T.); +#1656 = SURFACE_CURVE('',#1657,(#1661,#1668),.PCURVE_S1.); +#1657 = LINE('',#1658,#1659); +#1658 = CARTESIAN_POINT('',(-23.,37.6,0.)); +#1659 = VECTOR('',#1660,1.); +#1660 = DIRECTION('',(0.,0.,1.)); +#1661 = PCURVE('',#296,#1662); +#1662 = DEFINITIONAL_REPRESENTATION('',(#1663),#1667); +#1663 = LINE('',#1664,#1665); +#1664 = CARTESIAN_POINT('',(1.,0.)); +#1665 = VECTOR('',#1666,1.); +#1666 = DIRECTION('',(0.,-1.)); +#1667 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1668 = PCURVE('',#383,#1669); +#1669 = DEFINITIONAL_REPRESENTATION('',(#1670),#1674); +#1670 = LINE('',#1671,#1672); +#1671 = CARTESIAN_POINT('',(-0.,0.)); +#1672 = VECTOR('',#1673,1.); +#1673 = DIRECTION('',(-0.,-1.)); +#1674 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1675 = ORIENTED_EDGE('',*,*,#339,.F.); +#1676 = ADVANCED_FACE('',(#1677),#847,.F.); +#1677 = FACE_BOUND('',#1678,.T.); +#1678 = EDGE_LOOP('',(#1679,#1700,#1701,#1702)); +#1679 = ORIENTED_EDGE('',*,*,#1680,.T.); +#1680 = EDGE_CURVE('',#799,#1411,#1681,.T.); +#1681 = SURFACE_CURVE('',#1682,(#1686,#1693),.PCURVE_S1.); +#1682 = LINE('',#1683,#1684); +#1683 = CARTESIAN_POINT('',(-23.,-36.6,0.)); +#1684 = VECTOR('',#1685,1.); +#1685 = DIRECTION('',(0.,0.,1.)); +#1686 = PCURVE('',#847,#1687); +#1687 = DEFINITIONAL_REPRESENTATION('',(#1688),#1692); +#1688 = LINE('',#1689,#1690); +#1689 = CARTESIAN_POINT('',(-0.,0.)); +#1690 = VECTOR('',#1691,1.); +#1691 = DIRECTION('',(-0.,-1.)); +#1692 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1693 = PCURVE('',#814,#1694); +#1694 = DEFINITIONAL_REPRESENTATION('',(#1695),#1699); +#1695 = LINE('',#1696,#1697); +#1696 = CARTESIAN_POINT('',(1.,0.)); +#1697 = VECTOR('',#1698,1.); +#1698 = DIRECTION('',(0.,-1.)); +#1699 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1700 = ORIENTED_EDGE('',*,*,#1433,.T.); +#1701 = ORIENTED_EDGE('',*,*,#1626,.F.); +#1702 = ORIENTED_EDGE('',*,*,#826,.F.); +#1703 = ADVANCED_FACE('',(#1704),#383,.F.); +#1704 = FACE_BOUND('',#1705,.T.); +#1705 = EDGE_LOOP('',(#1706,#1707,#1708,#1729)); +#1706 = ORIENTED_EDGE('',*,*,#1655,.T.); +#1707 = ORIENTED_EDGE('',*,*,#1049,.T.); +#1708 = ORIENTED_EDGE('',*,*,#1709,.F.); +#1709 = EDGE_CURVE('',#363,#1050,#1710,.T.); +#1710 = SURFACE_CURVE('',#1711,(#1715,#1722),.PCURVE_S1.); +#1711 = LINE('',#1712,#1713); +#1712 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#1713 = VECTOR('',#1714,1.); +#1714 = DIRECTION('',(0.,0.,1.)); +#1715 = PCURVE('',#383,#1716); +#1716 = DEFINITIONAL_REPRESENTATION('',(#1717),#1721); +#1717 = LINE('',#1718,#1719); +#1718 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1719 = VECTOR('',#1720,1.); +#1720 = DIRECTION('',(-0.,-1.)); +#1721 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1722 = PCURVE('',#411,#1723); +#1723 = DEFINITIONAL_REPRESENTATION('',(#1724),#1728); +#1724 = LINE('',#1725,#1726); +#1725 = CARTESIAN_POINT('',(0.,-0.)); +#1726 = VECTOR('',#1727,1.); +#1727 = DIRECTION('',(0.,-1.)); +#1728 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1729 = ORIENTED_EDGE('',*,*,#362,.F.); +#1730 = ADVANCED_FACE('',(#1731),#814,.T.); +#1731 = FACE_BOUND('',#1732,.T.); +#1732 = EDGE_LOOP('',(#1733,#1754,#1755,#1756)); +#1733 = ORIENTED_EDGE('',*,*,#1734,.T.); +#1734 = EDGE_CURVE('',#766,#1383,#1735,.T.); +#1735 = SURFACE_CURVE('',#1736,(#1740,#1747),.PCURVE_S1.); +#1736 = LINE('',#1737,#1738); +#1737 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#1738 = VECTOR('',#1739,1.); +#1739 = DIRECTION('',(0.,0.,1.)); +#1740 = PCURVE('',#814,#1741); +#1741 = DEFINITIONAL_REPRESENTATION('',(#1742),#1746); +#1742 = LINE('',#1743,#1744); +#1743 = CARTESIAN_POINT('',(0.,0.)); +#1744 = VECTOR('',#1745,1.); +#1745 = DIRECTION('',(0.,-1.)); +#1746 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1747 = PCURVE('',#786,#1748); +#1748 = DEFINITIONAL_REPRESENTATION('',(#1749),#1753); +#1749 = LINE('',#1750,#1751); +#1750 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1751 = VECTOR('',#1752,1.); +#1752 = DIRECTION('',(-0.,-1.)); +#1753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1754 = ORIENTED_EDGE('',*,*,#1410,.T.); +#1755 = ORIENTED_EDGE('',*,*,#1680,.F.); +#1756 = ORIENTED_EDGE('',*,*,#798,.F.); +#1757 = ADVANCED_FACE('',(#1758),#411,.T.); +#1758 = FACE_BOUND('',#1759,.T.); +#1759 = EDGE_LOOP('',(#1760,#1761,#1762,#1783)); +#1760 = ORIENTED_EDGE('',*,*,#1709,.T.); +#1761 = ORIENTED_EDGE('',*,*,#1077,.T.); +#1762 = ORIENTED_EDGE('',*,*,#1763,.F.); +#1763 = EDGE_CURVE('',#396,#1078,#1764,.T.); +#1764 = SURFACE_CURVE('',#1765,(#1769,#1776),.PCURVE_S1.); +#1765 = LINE('',#1766,#1767); +#1766 = CARTESIAN_POINT('',(-30.,38.6,0.)); +#1767 = VECTOR('',#1768,1.); +#1768 = DIRECTION('',(0.,0.,1.)); +#1769 = PCURVE('',#411,#1770); +#1770 = DEFINITIONAL_REPRESENTATION('',(#1771),#1775); +#1771 = LINE('',#1772,#1773); +#1772 = CARTESIAN_POINT('',(6.,0.)); +#1773 = VECTOR('',#1774,1.); +#1774 = DIRECTION('',(0.,-1.)); +#1775 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1776 = PCURVE('',#440,#1777); +#1777 = DEFINITIONAL_REPRESENTATION('',(#1778),#1782); +#1778 = LINE('',#1779,#1780); +#1779 = CARTESIAN_POINT('',(0.,0.)); +#1780 = VECTOR('',#1781,1.); +#1781 = DIRECTION('',(0.,-1.)); +#1782 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1783 = ORIENTED_EDGE('',*,*,#395,.F.); +#1784 = ADVANCED_FACE('',(#1785),#786,.F.); +#1785 = FACE_BOUND('',#1786,.T.); +#1786 = EDGE_LOOP('',(#1787,#1808,#1809,#1810)); +#1787 = ORIENTED_EDGE('',*,*,#1788,.T.); +#1788 = EDGE_CURVE('',#738,#1360,#1789,.T.); +#1789 = SURFACE_CURVE('',#1790,(#1794,#1801),.PCURVE_S1.); +#1790 = LINE('',#1791,#1792); +#1791 = CARTESIAN_POINT('',(-24.,-38.6,0.)); +#1792 = VECTOR('',#1793,1.); +#1793 = DIRECTION('',(0.,0.,1.)); +#1794 = PCURVE('',#786,#1795); +#1795 = DEFINITIONAL_REPRESENTATION('',(#1796),#1800); +#1796 = LINE('',#1797,#1798); +#1797 = CARTESIAN_POINT('',(-0.,0.)); +#1798 = VECTOR('',#1799,1.); +#1799 = DIRECTION('',(-0.,-1.)); +#1800 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1801 = PCURVE('',#753,#1802); +#1802 = DEFINITIONAL_REPRESENTATION('',(#1803),#1807); +#1803 = LINE('',#1804,#1805); +#1804 = CARTESIAN_POINT('',(6.,0.)); +#1805 = VECTOR('',#1806,1.); +#1806 = DIRECTION('',(0.,-1.)); +#1807 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1808 = ORIENTED_EDGE('',*,*,#1382,.T.); +#1809 = ORIENTED_EDGE('',*,*,#1734,.F.); +#1810 = ORIENTED_EDGE('',*,*,#765,.F.); +#1811 = ADVANCED_FACE('',(#1812),#440,.T.); +#1812 = FACE_BOUND('',#1813,.T.); +#1813 = EDGE_LOOP('',(#1814,#1815,#1816,#1837)); +#1814 = ORIENTED_EDGE('',*,*,#1763,.T.); +#1815 = ORIENTED_EDGE('',*,*,#1100,.T.); +#1816 = ORIENTED_EDGE('',*,*,#1817,.F.); +#1817 = EDGE_CURVE('',#424,#1101,#1818,.T.); +#1818 = SURFACE_CURVE('',#1819,(#1823,#1830),.PCURVE_S1.); +#1819 = LINE('',#1820,#1821); +#1820 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#1821 = VECTOR('',#1822,1.); +#1822 = DIRECTION('',(0.,0.,1.)); +#1823 = PCURVE('',#440,#1824); +#1824 = DEFINITIONAL_REPRESENTATION('',(#1825),#1829); +#1825 = LINE('',#1826,#1827); +#1826 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1827 = VECTOR('',#1828,1.); +#1828 = DIRECTION('',(0.,-1.)); +#1829 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1830 = PCURVE('',#468,#1831); +#1831 = DEFINITIONAL_REPRESENTATION('',(#1832),#1836); +#1832 = LINE('',#1833,#1834); +#1833 = CARTESIAN_POINT('',(0.,0.)); +#1834 = VECTOR('',#1835,1.); +#1835 = DIRECTION('',(0.,-1.)); +#1836 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1837 = ORIENTED_EDGE('',*,*,#423,.F.); +#1838 = ADVANCED_FACE('',(#1839),#753,.T.); +#1839 = FACE_BOUND('',#1840,.T.); +#1840 = EDGE_LOOP('',(#1841,#1862,#1863,#1864)); +#1841 = ORIENTED_EDGE('',*,*,#1842,.T.); +#1842 = EDGE_CURVE('',#709,#1336,#1843,.T.); +#1843 = SURFACE_CURVE('',#1844,(#1848,#1855),.PCURVE_S1.); +#1844 = LINE('',#1845,#1846); +#1845 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#1846 = VECTOR('',#1847,1.); +#1847 = DIRECTION('',(0.,0.,1.)); +#1848 = PCURVE('',#753,#1849); +#1849 = DEFINITIONAL_REPRESENTATION('',(#1850),#1854); +#1850 = LINE('',#1851,#1852); +#1851 = CARTESIAN_POINT('',(0.,0.)); +#1852 = VECTOR('',#1853,1.); +#1853 = DIRECTION('',(0.,-1.)); +#1854 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1855 = PCURVE('',#725,#1856); +#1856 = DEFINITIONAL_REPRESENTATION('',(#1857),#1861); +#1857 = LINE('',#1858,#1859); +#1858 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1859 = VECTOR('',#1860,1.); +#1860 = DIRECTION('',(0.,-1.)); +#1861 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1862 = ORIENTED_EDGE('',*,*,#1359,.T.); +#1863 = ORIENTED_EDGE('',*,*,#1788,.F.); +#1864 = ORIENTED_EDGE('',*,*,#737,.F.); +#1865 = ADVANCED_FACE('',(#1866),#468,.T.); +#1866 = FACE_BOUND('',#1867,.T.); +#1867 = EDGE_LOOP('',(#1868,#1869,#1870,#1891)); +#1868 = ORIENTED_EDGE('',*,*,#1817,.T.); +#1869 = ORIENTED_EDGE('',*,*,#1124,.T.); +#1870 = ORIENTED_EDGE('',*,*,#1871,.F.); +#1871 = EDGE_CURVE('',#453,#1125,#1872,.T.); +#1872 = SURFACE_CURVE('',#1873,(#1877,#1884),.PCURVE_S1.); +#1873 = LINE('',#1874,#1875); +#1874 = CARTESIAN_POINT('',(-33.,61.6,0.)); +#1875 = VECTOR('',#1876,1.); +#1876 = DIRECTION('',(0.,0.,1.)); +#1877 = PCURVE('',#468,#1878); +#1878 = DEFINITIONAL_REPRESENTATION('',(#1879),#1883); +#1879 = LINE('',#1880,#1881); +#1880 = CARTESIAN_POINT('',(20.,0.)); +#1881 = VECTOR('',#1882,1.); +#1882 = DIRECTION('',(0.,-1.)); +#1883 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1884 = PCURVE('',#497,#1885); +#1885 = DEFINITIONAL_REPRESENTATION('',(#1886),#1890); +#1886 = LINE('',#1887,#1888); +#1887 = CARTESIAN_POINT('',(0.,0.)); +#1888 = VECTOR('',#1889,1.); +#1889 = DIRECTION('',(0.,-1.)); +#1890 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1891 = ORIENTED_EDGE('',*,*,#452,.F.); +#1892 = ADVANCED_FACE('',(#1893),#725,.T.); +#1893 = FACE_BOUND('',#1894,.T.); +#1894 = EDGE_LOOP('',(#1895,#1916,#1917,#1918)); +#1895 = ORIENTED_EDGE('',*,*,#1896,.T.); +#1896 = EDGE_CURVE('',#681,#1313,#1897,.T.); +#1897 = SURFACE_CURVE('',#1898,(#1902,#1909),.PCURVE_S1.); +#1898 = LINE('',#1899,#1900); +#1899 = CARTESIAN_POINT('',(-33.,-41.6,0.)); +#1900 = VECTOR('',#1901,1.); +#1901 = DIRECTION('',(0.,0.,1.)); +#1902 = PCURVE('',#725,#1903); +#1903 = DEFINITIONAL_REPRESENTATION('',(#1904),#1908); +#1904 = LINE('',#1905,#1906); +#1905 = CARTESIAN_POINT('',(0.,0.)); +#1906 = VECTOR('',#1907,1.); +#1907 = DIRECTION('',(0.,-1.)); +#1908 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1909 = PCURVE('',#696,#1910); +#1910 = DEFINITIONAL_REPRESENTATION('',(#1911),#1915); +#1911 = LINE('',#1912,#1913); +#1912 = CARTESIAN_POINT('',(20.,0.)); +#1913 = VECTOR('',#1914,1.); +#1914 = DIRECTION('',(0.,-1.)); +#1915 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1916 = ORIENTED_EDGE('',*,*,#1335,.T.); +#1917 = ORIENTED_EDGE('',*,*,#1842,.F.); +#1918 = ORIENTED_EDGE('',*,*,#708,.F.); +#1919 = ADVANCED_FACE('',(#1920),#497,.T.); +#1920 = FACE_BOUND('',#1921,.T.); +#1921 = EDGE_LOOP('',(#1922,#1923,#1924,#1945)); +#1922 = ORIENTED_EDGE('',*,*,#1871,.T.); +#1923 = ORIENTED_EDGE('',*,*,#1147,.T.); +#1924 = ORIENTED_EDGE('',*,*,#1925,.F.); +#1925 = EDGE_CURVE('',#481,#1148,#1926,.T.); +#1926 = SURFACE_CURVE('',#1927,(#1931,#1938),.PCURVE_S1.); +#1927 = LINE('',#1928,#1929); +#1928 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#1929 = VECTOR('',#1930,1.); +#1930 = DIRECTION('',(0.,0.,1.)); +#1931 = PCURVE('',#497,#1932); +#1932 = DEFINITIONAL_REPRESENTATION('',(#1933),#1937); +#1933 = LINE('',#1934,#1935); +#1934 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1935 = VECTOR('',#1936,1.); +#1936 = DIRECTION('',(0.,-1.)); +#1937 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1938 = PCURVE('',#525,#1939); +#1939 = DEFINITIONAL_REPRESENTATION('',(#1940),#1944); +#1940 = LINE('',#1941,#1942); +#1941 = CARTESIAN_POINT('',(0.,0.)); +#1942 = VECTOR('',#1943,1.); +#1943 = DIRECTION('',(0.,-1.)); +#1944 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1945 = ORIENTED_EDGE('',*,*,#480,.F.); +#1946 = ADVANCED_FACE('',(#1947),#696,.T.); +#1947 = FACE_BOUND('',#1948,.T.); +#1948 = EDGE_LOOP('',(#1949,#1970,#1971,#1972)); +#1949 = ORIENTED_EDGE('',*,*,#1950,.T.); +#1950 = EDGE_CURVE('',#652,#1289,#1951,.T.); +#1951 = SURFACE_CURVE('',#1952,(#1956,#1963),.PCURVE_S1.); +#1952 = LINE('',#1953,#1954); +#1953 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#1954 = VECTOR('',#1955,1.); +#1955 = DIRECTION('',(0.,0.,1.)); +#1956 = PCURVE('',#696,#1957); +#1957 = DEFINITIONAL_REPRESENTATION('',(#1958),#1962); +#1958 = LINE('',#1959,#1960); +#1959 = CARTESIAN_POINT('',(0.,0.)); +#1960 = VECTOR('',#1961,1.); +#1961 = DIRECTION('',(0.,-1.)); +#1962 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1963 = PCURVE('',#668,#1964); +#1964 = DEFINITIONAL_REPRESENTATION('',(#1965),#1969); +#1965 = LINE('',#1966,#1967); +#1966 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1967 = VECTOR('',#1968,1.); +#1968 = DIRECTION('',(0.,-1.)); +#1969 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1970 = ORIENTED_EDGE('',*,*,#1312,.T.); +#1971 = ORIENTED_EDGE('',*,*,#1896,.F.); +#1972 = ORIENTED_EDGE('',*,*,#680,.F.); +#1973 = ADVANCED_FACE('',(#1974),#525,.T.); +#1974 = FACE_BOUND('',#1975,.T.); +#1975 = EDGE_LOOP('',(#1976,#1977,#1978,#1999)); +#1976 = ORIENTED_EDGE('',*,*,#1925,.T.); +#1977 = ORIENTED_EDGE('',*,*,#1171,.T.); +#1978 = ORIENTED_EDGE('',*,*,#1979,.F.); +#1979 = EDGE_CURVE('',#510,#1172,#1980,.T.); +#1980 = SURFACE_CURVE('',#1981,(#1985,#1992),.PCURVE_S1.); +#1981 = LINE('',#1982,#1983); +#1982 = CARTESIAN_POINT('',(26.,64.6,0.)); +#1983 = VECTOR('',#1984,1.); +#1984 = DIRECTION('',(0.,0.,1.)); +#1985 = PCURVE('',#525,#1986); +#1986 = DEFINITIONAL_REPRESENTATION('',(#1987),#1991); +#1987 = LINE('',#1988,#1989); +#1988 = CARTESIAN_POINT('',(56.,0.)); +#1989 = VECTOR('',#1990,1.); +#1990 = DIRECTION('',(0.,-1.)); +#1991 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1992 = PCURVE('',#554,#1993); +#1993 = DEFINITIONAL_REPRESENTATION('',(#1994),#1998); +#1994 = LINE('',#1995,#1996); +#1995 = CARTESIAN_POINT('',(0.,0.)); +#1996 = VECTOR('',#1997,1.); +#1997 = DIRECTION('',(0.,-1.)); +#1998 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1999 = ORIENTED_EDGE('',*,*,#509,.F.); +#2000 = ADVANCED_FACE('',(#2001),#668,.T.); +#2001 = FACE_BOUND('',#2002,.T.); +#2002 = EDGE_LOOP('',(#2003,#2024,#2025,#2026)); +#2003 = ORIENTED_EDGE('',*,*,#2004,.T.); +#2004 = EDGE_CURVE('',#624,#1266,#2005,.T.); +#2005 = SURFACE_CURVE('',#2006,(#2010,#2017),.PCURVE_S1.); +#2006 = LINE('',#2007,#2008); +#2007 = CARTESIAN_POINT('',(-30.,-64.6,0.)); +#2008 = VECTOR('',#2009,1.); +#2009 = DIRECTION('',(0.,0.,1.)); +#2010 = PCURVE('',#668,#2011); +#2011 = DEFINITIONAL_REPRESENTATION('',(#2012),#2016); +#2012 = LINE('',#2013,#2014); +#2013 = CARTESIAN_POINT('',(0.,0.)); +#2014 = VECTOR('',#2015,1.); +#2015 = DIRECTION('',(0.,-1.)); +#2016 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2017 = PCURVE('',#639,#2018); +#2018 = DEFINITIONAL_REPRESENTATION('',(#2019),#2023); +#2019 = LINE('',#2020,#2021); +#2020 = CARTESIAN_POINT('',(56.,0.)); +#2021 = VECTOR('',#2022,1.); +#2022 = DIRECTION('',(0.,-1.)); +#2023 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2024 = ORIENTED_EDGE('',*,*,#1288,.T.); +#2025 = ORIENTED_EDGE('',*,*,#1950,.F.); +#2026 = ORIENTED_EDGE('',*,*,#651,.F.); +#2027 = ADVANCED_FACE('',(#2028),#554,.T.); +#2028 = FACE_BOUND('',#2029,.T.); +#2029 = EDGE_LOOP('',(#2030,#2031,#2032,#2053)); +#2030 = ORIENTED_EDGE('',*,*,#1979,.T.); +#2031 = ORIENTED_EDGE('',*,*,#1194,.T.); +#2032 = ORIENTED_EDGE('',*,*,#2033,.F.); +#2033 = EDGE_CURVE('',#538,#1195,#2034,.T.); +#2034 = SURFACE_CURVE('',#2035,(#2039,#2046),.PCURVE_S1.); +#2035 = LINE('',#2036,#2037); +#2036 = CARTESIAN_POINT('',(29.,61.6,0.)); +#2037 = VECTOR('',#2038,1.); +#2038 = DIRECTION('',(0.,0.,1.)); +#2039 = PCURVE('',#554,#2040); +#2040 = DEFINITIONAL_REPRESENTATION('',(#2041),#2045); +#2041 = LINE('',#2042,#2043); +#2042 = CARTESIAN_POINT('',(1.570796327797,0.)); +#2043 = VECTOR('',#2044,1.); +#2044 = DIRECTION('',(0.,-1.)); +#2045 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2046 = PCURVE('',#582,#2047); +#2047 = DEFINITIONAL_REPRESENTATION('',(#2048),#2052); +#2048 = LINE('',#2049,#2050); +#2049 = CARTESIAN_POINT('',(0.,0.)); +#2050 = VECTOR('',#2051,1.); +#2051 = DIRECTION('',(0.,-1.)); +#2052 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2053 = ORIENTED_EDGE('',*,*,#537,.F.); +#2054 = ADVANCED_FACE('',(#2055),#639,.T.); +#2055 = FACE_BOUND('',#2056,.T.); +#2056 = EDGE_LOOP('',(#2057,#2078,#2079,#2080)); +#2057 = ORIENTED_EDGE('',*,*,#2058,.T.); +#2058 = EDGE_CURVE('',#595,#1242,#2059,.T.); +#2059 = SURFACE_CURVE('',#2060,(#2064,#2071),.PCURVE_S1.); +#2060 = LINE('',#2061,#2062); +#2061 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#2062 = VECTOR('',#2063,1.); +#2063 = DIRECTION('',(0.,0.,1.)); +#2064 = PCURVE('',#639,#2065); +#2065 = DEFINITIONAL_REPRESENTATION('',(#2066),#2070); +#2066 = LINE('',#2067,#2068); +#2067 = CARTESIAN_POINT('',(0.,-0.)); +#2068 = VECTOR('',#2069,1.); +#2069 = DIRECTION('',(0.,-1.)); +#2070 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2071 = PCURVE('',#611,#2072); +#2072 = DEFINITIONAL_REPRESENTATION('',(#2073),#2077); +#2073 = LINE('',#2074,#2075); +#2074 = CARTESIAN_POINT('',(1.570796326659,0.)); +#2075 = VECTOR('',#2076,1.); +#2076 = DIRECTION('',(0.,-1.)); +#2077 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2078 = ORIENTED_EDGE('',*,*,#1265,.T.); +#2079 = ORIENTED_EDGE('',*,*,#2004,.F.); +#2080 = ORIENTED_EDGE('',*,*,#623,.F.); +#2081 = ADVANCED_FACE('',(#2082),#582,.T.); +#2082 = FACE_BOUND('',#2083,.T.); +#2083 = EDGE_LOOP('',(#2084,#2085,#2086,#2107)); +#2084 = ORIENTED_EDGE('',*,*,#2033,.T.); +#2085 = ORIENTED_EDGE('',*,*,#1218,.T.); +#2086 = ORIENTED_EDGE('',*,*,#2087,.F.); +#2087 = EDGE_CURVE('',#567,#1219,#2088,.T.); +#2088 = SURFACE_CURVE('',#2089,(#2093,#2100),.PCURVE_S1.); +#2089 = LINE('',#2090,#2091); +#2090 = CARTESIAN_POINT('',(29.,-61.6,0.)); +#2091 = VECTOR('',#2092,1.); +#2092 = DIRECTION('',(0.,0.,1.)); +#2093 = PCURVE('',#582,#2094); +#2094 = DEFINITIONAL_REPRESENTATION('',(#2095),#2099); +#2095 = LINE('',#2096,#2097); +#2096 = CARTESIAN_POINT('',(123.2,0.)); +#2097 = VECTOR('',#2098,1.); +#2098 = DIRECTION('',(0.,-1.)); +#2099 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2100 = PCURVE('',#611,#2101); +#2101 = DEFINITIONAL_REPRESENTATION('',(#2102),#2106); +#2102 = LINE('',#2103,#2104); +#2103 = CARTESIAN_POINT('',(0.,0.)); +#2104 = VECTOR('',#2105,1.); +#2105 = DIRECTION('',(0.,-1.)); +#2106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2107 = ORIENTED_EDGE('',*,*,#566,.F.); +#2108 = ADVANCED_FACE('',(#2109),#611,.T.); +#2109 = FACE_BOUND('',#2110,.T.); +#2110 = EDGE_LOOP('',(#2111,#2112,#2113,#2114)); +#2111 = ORIENTED_EDGE('',*,*,#2087,.T.); +#2112 = ORIENTED_EDGE('',*,*,#1241,.T.); +#2113 = ORIENTED_EDGE('',*,*,#2058,.F.); +#2114 = ORIENTED_EDGE('',*,*,#594,.F.); +#2115 = ADVANCED_FACE('',(#2116),#904,.F.); +#2116 = FACE_BOUND('',#2117,.T.); +#2117 = EDGE_LOOP('',(#2118,#2141,#2168,#2169)); +#2118 = ORIENTED_EDGE('',*,*,#2119,.T.); +#2119 = EDGE_CURVE('',#884,#2120,#2122,.T.); +#2120 = VERTEX_POINT('',#2121); +#2121 = CARTESIAN_POINT('',(28.15,-61.6,2.3)); +#2122 = SEAM_CURVE('',#2123,(#2127,#2134),.PCURVE_S1.); +#2123 = LINE('',#2124,#2125); +#2124 = CARTESIAN_POINT('',(28.15,-61.6,0.)); +#2125 = VECTOR('',#2126,1.); +#2126 = DIRECTION('',(0.,0.,1.)); +#2127 = PCURVE('',#904,#2128); +#2128 = DEFINITIONAL_REPRESENTATION('',(#2129),#2133); +#2129 = LINE('',#2130,#2131); +#2130 = CARTESIAN_POINT('',(-0.,0.)); +#2131 = VECTOR('',#2132,1.); +#2132 = DIRECTION('',(-0.,-1.)); +#2133 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2134 = PCURVE('',#904,#2135); +#2135 = DEFINITIONAL_REPRESENTATION('',(#2136),#2140); +#2136 = LINE('',#2137,#2138); +#2137 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2138 = VECTOR('',#2139,1.); +#2139 = DIRECTION('',(-0.,-1.)); +#2140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2141 = ORIENTED_EDGE('',*,*,#2142,.T.); +#2142 = EDGE_CURVE('',#2120,#2120,#2143,.T.); +#2143 = SURFACE_CURVE('',#2144,(#2149,#2156),.PCURVE_S1.); +#2144 = CIRCLE('',#2145,2.15); +#2145 = AXIS2_PLACEMENT_3D('',#2146,#2147,#2148); +#2146 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2147 = DIRECTION('',(0.,0.,1.)); +#2148 = DIRECTION('',(1.,0.,0.)); +#2149 = PCURVE('',#904,#2150); +#2150 = DEFINITIONAL_REPRESENTATION('',(#2151),#2155); +#2151 = LINE('',#2152,#2153); +#2152 = CARTESIAN_POINT('',(-0.,-2.3)); +#2153 = VECTOR('',#2154,1.); +#2154 = DIRECTION('',(-1.,0.)); +#2155 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2156 = PCURVE('',#2157,#2162); +#2157 = PLANE('',#2158); +#2158 = AXIS2_PLACEMENT_3D('',#2159,#2160,#2161); +#2159 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2160 = DIRECTION('',(0.,0.,1.)); +#2161 = DIRECTION('',(1.,0.,-0.)); +#2162 = DEFINITIONAL_REPRESENTATION('',(#2163),#2167); +#2163 = CIRCLE('',#2164,2.15); +#2164 = AXIS2_PLACEMENT_2D('',#2165,#2166); +#2165 = CARTESIAN_POINT('',(0.,-7.105427357601E-15)); +#2166 = DIRECTION('',(1.,0.)); +#2167 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2168 = ORIENTED_EDGE('',*,*,#2119,.F.); +#2169 = ORIENTED_EDGE('',*,*,#883,.F.); +#2170 = ADVANCED_FACE('',(#2171),#939,.F.); +#2171 = FACE_BOUND('',#2172,.T.); +#2172 = EDGE_LOOP('',(#2173,#2196,#2223,#2224)); +#2173 = ORIENTED_EDGE('',*,*,#2174,.T.); +#2174 = EDGE_CURVE('',#919,#2175,#2177,.T.); +#2175 = VERTEX_POINT('',#2176); +#2176 = CARTESIAN_POINT('',(-27.85,-61.6,2.3)); +#2177 = SEAM_CURVE('',#2178,(#2182,#2189),.PCURVE_S1.); +#2178 = LINE('',#2179,#2180); +#2179 = CARTESIAN_POINT('',(-27.85,-61.6,0.)); +#2180 = VECTOR('',#2181,1.); +#2181 = DIRECTION('',(0.,0.,1.)); +#2182 = PCURVE('',#939,#2183); +#2183 = DEFINITIONAL_REPRESENTATION('',(#2184),#2188); +#2184 = LINE('',#2185,#2186); +#2185 = CARTESIAN_POINT('',(-0.,0.)); +#2186 = VECTOR('',#2187,1.); +#2187 = DIRECTION('',(-0.,-1.)); +#2188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2189 = PCURVE('',#939,#2190); +#2190 = DEFINITIONAL_REPRESENTATION('',(#2191),#2195); +#2191 = LINE('',#2192,#2193); +#2192 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2193 = VECTOR('',#2194,1.); +#2194 = DIRECTION('',(-0.,-1.)); +#2195 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2196 = ORIENTED_EDGE('',*,*,#2197,.T.); +#2197 = EDGE_CURVE('',#2175,#2175,#2198,.T.); +#2198 = SURFACE_CURVE('',#2199,(#2204,#2211),.PCURVE_S1.); +#2199 = CIRCLE('',#2200,2.15); +#2200 = AXIS2_PLACEMENT_3D('',#2201,#2202,#2203); +#2201 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2202 = DIRECTION('',(0.,0.,1.)); +#2203 = DIRECTION('',(1.,0.,0.)); +#2204 = PCURVE('',#939,#2205); +#2205 = DEFINITIONAL_REPRESENTATION('',(#2206),#2210); +#2206 = LINE('',#2207,#2208); +#2207 = CARTESIAN_POINT('',(-0.,-2.3)); +#2208 = VECTOR('',#2209,1.); +#2209 = DIRECTION('',(-1.,0.)); +#2210 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2211 = PCURVE('',#2212,#2217); +#2212 = PLANE('',#2213); +#2213 = AXIS2_PLACEMENT_3D('',#2214,#2215,#2216); +#2214 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2215 = DIRECTION('',(0.,0.,1.)); +#2216 = DIRECTION('',(1.,0.,-0.)); +#2217 = DEFINITIONAL_REPRESENTATION('',(#2218),#2222); +#2218 = CIRCLE('',#2219,2.15); +#2219 = AXIS2_PLACEMENT_2D('',#2220,#2221); +#2220 = CARTESIAN_POINT('',(-3.552713678801E-15,-7.105427357601E-15)); +#2221 = DIRECTION('',(1.,0.)); +#2222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2223 = ORIENTED_EDGE('',*,*,#2174,.F.); +#2224 = ORIENTED_EDGE('',*,*,#918,.F.); +#2225 = ADVANCED_FACE('',(#2226),#974,.F.); +#2226 = FACE_BOUND('',#2227,.T.); +#2227 = EDGE_LOOP('',(#2228,#2251,#2278,#2279)); +#2228 = ORIENTED_EDGE('',*,*,#2229,.T.); +#2229 = EDGE_CURVE('',#954,#2230,#2232,.T.); +#2230 = VERTEX_POINT('',#2231); +#2231 = CARTESIAN_POINT('',(28.15,61.6,2.3)); +#2232 = SEAM_CURVE('',#2233,(#2237,#2244),.PCURVE_S1.); +#2233 = LINE('',#2234,#2235); +#2234 = CARTESIAN_POINT('',(28.15,61.6,0.)); +#2235 = VECTOR('',#2236,1.); +#2236 = DIRECTION('',(0.,0.,1.)); +#2237 = PCURVE('',#974,#2238); +#2238 = DEFINITIONAL_REPRESENTATION('',(#2239),#2243); +#2239 = LINE('',#2240,#2241); +#2240 = CARTESIAN_POINT('',(-0.,0.)); +#2241 = VECTOR('',#2242,1.); +#2242 = DIRECTION('',(-0.,-1.)); +#2243 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2244 = PCURVE('',#974,#2245); +#2245 = DEFINITIONAL_REPRESENTATION('',(#2246),#2250); +#2246 = LINE('',#2247,#2248); +#2247 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2248 = VECTOR('',#2249,1.); +#2249 = DIRECTION('',(-0.,-1.)); +#2250 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2251 = ORIENTED_EDGE('',*,*,#2252,.T.); +#2252 = EDGE_CURVE('',#2230,#2230,#2253,.T.); +#2253 = SURFACE_CURVE('',#2254,(#2259,#2266),.PCURVE_S1.); +#2254 = CIRCLE('',#2255,2.15); +#2255 = AXIS2_PLACEMENT_3D('',#2256,#2257,#2258); +#2256 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2257 = DIRECTION('',(0.,0.,1.)); +#2258 = DIRECTION('',(1.,0.,0.)); +#2259 = PCURVE('',#974,#2260); +#2260 = DEFINITIONAL_REPRESENTATION('',(#2261),#2265); +#2261 = LINE('',#2262,#2263); +#2262 = CARTESIAN_POINT('',(-0.,-2.3)); +#2263 = VECTOR('',#2264,1.); +#2264 = DIRECTION('',(-1.,0.)); +#2265 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2266 = PCURVE('',#2267,#2272); +#2267 = PLANE('',#2268); +#2268 = AXIS2_PLACEMENT_3D('',#2269,#2270,#2271); +#2269 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2270 = DIRECTION('',(0.,0.,1.)); +#2271 = DIRECTION('',(1.,0.,-0.)); +#2272 = DEFINITIONAL_REPRESENTATION('',(#2273),#2277); +#2273 = CIRCLE('',#2274,2.15); +#2274 = AXIS2_PLACEMENT_2D('',#2275,#2276); +#2275 = CARTESIAN_POINT('',(0.,7.105427357601E-15)); +#2276 = DIRECTION('',(1.,0.)); +#2277 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2278 = ORIENTED_EDGE('',*,*,#2229,.F.); +#2279 = ORIENTED_EDGE('',*,*,#953,.F.); +#2280 = ADVANCED_FACE('',(#2281),#1009,.F.); +#2281 = FACE_BOUND('',#2282,.T.); +#2282 = EDGE_LOOP('',(#2283,#2306,#2333,#2334)); +#2283 = ORIENTED_EDGE('',*,*,#2284,.T.); +#2284 = EDGE_CURVE('',#989,#2285,#2287,.T.); +#2285 = VERTEX_POINT('',#2286); +#2286 = CARTESIAN_POINT('',(-27.85,61.6,2.3)); +#2287 = SEAM_CURVE('',#2288,(#2292,#2299),.PCURVE_S1.); +#2288 = LINE('',#2289,#2290); +#2289 = CARTESIAN_POINT('',(-27.85,61.6,0.)); +#2290 = VECTOR('',#2291,1.); +#2291 = DIRECTION('',(0.,0.,1.)); +#2292 = PCURVE('',#1009,#2293); +#2293 = DEFINITIONAL_REPRESENTATION('',(#2294),#2298); +#2294 = LINE('',#2295,#2296); +#2295 = CARTESIAN_POINT('',(-0.,0.)); +#2296 = VECTOR('',#2297,1.); +#2297 = DIRECTION('',(-0.,-1.)); +#2298 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2299 = PCURVE('',#1009,#2300); +#2300 = DEFINITIONAL_REPRESENTATION('',(#2301),#2305); +#2301 = LINE('',#2302,#2303); +#2302 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2303 = VECTOR('',#2304,1.); +#2304 = DIRECTION('',(-0.,-1.)); +#2305 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2306 = ORIENTED_EDGE('',*,*,#2307,.T.); +#2307 = EDGE_CURVE('',#2285,#2285,#2308,.T.); +#2308 = SURFACE_CURVE('',#2309,(#2314,#2321),.PCURVE_S1.); +#2309 = CIRCLE('',#2310,2.15); +#2310 = AXIS2_PLACEMENT_3D('',#2311,#2312,#2313); +#2311 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2312 = DIRECTION('',(0.,0.,1.)); +#2313 = DIRECTION('',(1.,0.,0.)); +#2314 = PCURVE('',#1009,#2315); +#2315 = DEFINITIONAL_REPRESENTATION('',(#2316),#2320); +#2316 = LINE('',#2317,#2318); +#2317 = CARTESIAN_POINT('',(-0.,-2.3)); +#2318 = VECTOR('',#2319,1.); +#2319 = DIRECTION('',(-1.,0.)); +#2320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2321 = PCURVE('',#2322,#2327); +#2322 = PLANE('',#2323); +#2323 = AXIS2_PLACEMENT_3D('',#2324,#2325,#2326); +#2324 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2325 = DIRECTION('',(0.,0.,1.)); +#2326 = DIRECTION('',(1.,0.,-0.)); +#2327 = DEFINITIONAL_REPRESENTATION('',(#2328),#2332); +#2328 = CIRCLE('',#2329,2.15); +#2329 = AXIS2_PLACEMENT_2D('',#2330,#2331); +#2330 = CARTESIAN_POINT('',(-3.552713678801E-15,7.105427357601E-15)); +#2331 = DIRECTION('',(1.,0.)); +#2332 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2333 = ORIENTED_EDGE('',*,*,#2284,.F.); +#2334 = ORIENTED_EDGE('',*,*,#988,.F.); +#2335 = ADVANCED_FACE('',(#2336),#1506,.F.); +#2336 = FACE_BOUND('',#2337,.T.); +#2337 = EDGE_LOOP('',(#2338,#2366,#2387,#2388)); +#2338 = ORIENTED_EDGE('',*,*,#2339,.T.); +#2339 = EDGE_CURVE('',#2340,#2340,#2342,.T.); +#2340 = VERTEX_POINT('',#2341); +#2341 = CARTESIAN_POINT('',(27.15,-61.6,2.3)); +#2342 = SURFACE_CURVE('',#2343,(#2348,#2355),.PCURVE_S1.); +#2343 = CIRCLE('',#2344,1.15); +#2344 = AXIS2_PLACEMENT_3D('',#2345,#2346,#2347); +#2345 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2346 = DIRECTION('',(0.,0.,-1.)); +#2347 = DIRECTION('',(1.,0.,0.)); +#2348 = PCURVE('',#1506,#2349); +#2349 = DEFINITIONAL_REPRESENTATION('',(#2350),#2354); +#2350 = LINE('',#2351,#2352); +#2351 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2352 = VECTOR('',#2353,1.); +#2353 = DIRECTION('',(1.,-0.)); +#2354 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2355 = PCURVE('',#2157,#2356); +#2356 = DEFINITIONAL_REPRESENTATION('',(#2357),#2365); +#2357 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2358,#2359,#2360,#2361, +#2362,#2363,#2364),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2358 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2359 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2360 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2361 = CARTESIAN_POINT('',(-2.3,-7.387096121405E-15)); +#2362 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2363 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2364 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2365 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2366 = ORIENTED_EDGE('',*,*,#2367,.T.); +#2367 = EDGE_CURVE('',#2340,#1486,#2368,.T.); +#2368 = SEAM_CURVE('',#2369,(#2373,#2380),.PCURVE_S1.); +#2369 = LINE('',#2370,#2371); +#2370 = CARTESIAN_POINT('',(27.15,-61.6,0.)); +#2371 = VECTOR('',#2372,1.); +#2372 = DIRECTION('',(0.,0.,1.)); +#2373 = PCURVE('',#1506,#2374); +#2374 = DEFINITIONAL_REPRESENTATION('',(#2375),#2379); +#2375 = LINE('',#2376,#2377); +#2376 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2377 = VECTOR('',#2378,1.); +#2378 = DIRECTION('',(-0.,-1.)); +#2379 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2380 = PCURVE('',#1506,#2381); +#2381 = DEFINITIONAL_REPRESENTATION('',(#2382),#2386); +#2382 = LINE('',#2383,#2384); +#2383 = CARTESIAN_POINT('',(-0.,0.)); +#2384 = VECTOR('',#2385,1.); +#2385 = DIRECTION('',(-0.,-1.)); +#2386 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2387 = ORIENTED_EDGE('',*,*,#1485,.T.); +#2388 = ORIENTED_EDGE('',*,*,#2367,.F.); +#2389 = ADVANCED_FACE('',(#2390),#1541,.F.); +#2390 = FACE_BOUND('',#2391,.T.); +#2391 = EDGE_LOOP('',(#2392,#2420,#2441,#2442)); +#2392 = ORIENTED_EDGE('',*,*,#2393,.T.); +#2393 = EDGE_CURVE('',#2394,#2394,#2396,.T.); +#2394 = VERTEX_POINT('',#2395); +#2395 = CARTESIAN_POINT('',(-28.85,-61.6,2.3)); +#2396 = SURFACE_CURVE('',#2397,(#2402,#2409),.PCURVE_S1.); +#2397 = CIRCLE('',#2398,1.15); +#2398 = AXIS2_PLACEMENT_3D('',#2399,#2400,#2401); +#2399 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2400 = DIRECTION('',(0.,0.,-1.)); +#2401 = DIRECTION('',(1.,0.,0.)); +#2402 = PCURVE('',#1541,#2403); +#2403 = DEFINITIONAL_REPRESENTATION('',(#2404),#2408); +#2404 = LINE('',#2405,#2406); +#2405 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2406 = VECTOR('',#2407,1.); +#2407 = DIRECTION('',(1.,-0.)); +#2408 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2409 = PCURVE('',#2212,#2410); +#2410 = DEFINITIONAL_REPRESENTATION('',(#2411),#2419); +#2411 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2412,#2413,#2414,#2415, +#2416,#2417,#2418),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2412 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2413 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2414 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2415 = CARTESIAN_POINT('',(-2.3,-7.387096121405E-15)); +#2416 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2417 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2418 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2419 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2420 = ORIENTED_EDGE('',*,*,#2421,.T.); +#2421 = EDGE_CURVE('',#2394,#1521,#2422,.T.); +#2422 = SEAM_CURVE('',#2423,(#2427,#2434),.PCURVE_S1.); +#2423 = LINE('',#2424,#2425); +#2424 = CARTESIAN_POINT('',(-28.85,-61.6,0.)); +#2425 = VECTOR('',#2426,1.); +#2426 = DIRECTION('',(0.,0.,1.)); +#2427 = PCURVE('',#1541,#2428); +#2428 = DEFINITIONAL_REPRESENTATION('',(#2429),#2433); +#2429 = LINE('',#2430,#2431); +#2430 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2431 = VECTOR('',#2432,1.); +#2432 = DIRECTION('',(-0.,-1.)); +#2433 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2434 = PCURVE('',#1541,#2435); +#2435 = DEFINITIONAL_REPRESENTATION('',(#2436),#2440); +#2436 = LINE('',#2437,#2438); +#2437 = CARTESIAN_POINT('',(-0.,0.)); +#2438 = VECTOR('',#2439,1.); +#2439 = DIRECTION('',(-0.,-1.)); +#2440 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2441 = ORIENTED_EDGE('',*,*,#1520,.T.); +#2442 = ORIENTED_EDGE('',*,*,#2421,.F.); +#2443 = ADVANCED_FACE('',(#2444),#1576,.F.); +#2444 = FACE_BOUND('',#2445,.T.); +#2445 = EDGE_LOOP('',(#2446,#2474,#2495,#2496)); +#2446 = ORIENTED_EDGE('',*,*,#2447,.T.); +#2447 = EDGE_CURVE('',#2448,#2448,#2450,.T.); +#2448 = VERTEX_POINT('',#2449); +#2449 = CARTESIAN_POINT('',(27.15,61.6,2.3)); +#2450 = SURFACE_CURVE('',#2451,(#2456,#2463),.PCURVE_S1.); +#2451 = CIRCLE('',#2452,1.15); +#2452 = AXIS2_PLACEMENT_3D('',#2453,#2454,#2455); +#2453 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2454 = DIRECTION('',(0.,0.,-1.)); +#2455 = DIRECTION('',(1.,0.,0.)); +#2456 = PCURVE('',#1576,#2457); +#2457 = DEFINITIONAL_REPRESENTATION('',(#2458),#2462); +#2458 = LINE('',#2459,#2460); +#2459 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2460 = VECTOR('',#2461,1.); +#2461 = DIRECTION('',(1.,-0.)); +#2462 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2463 = PCURVE('',#2267,#2464); +#2464 = DEFINITIONAL_REPRESENTATION('',(#2465),#2473); +#2465 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2466,#2467,#2468,#2469, +#2470,#2471,#2472),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2466 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2467 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2468 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2469 = CARTESIAN_POINT('',(-2.3,6.823758593797E-15)); +#2470 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2471 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2472 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2473 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2474 = ORIENTED_EDGE('',*,*,#2475,.T.); +#2475 = EDGE_CURVE('',#2448,#1556,#2476,.T.); +#2476 = SEAM_CURVE('',#2477,(#2481,#2488),.PCURVE_S1.); +#2477 = LINE('',#2478,#2479); +#2478 = CARTESIAN_POINT('',(27.15,61.6,0.)); +#2479 = VECTOR('',#2480,1.); +#2480 = DIRECTION('',(0.,0.,1.)); +#2481 = PCURVE('',#1576,#2482); +#2482 = DEFINITIONAL_REPRESENTATION('',(#2483),#2487); +#2483 = LINE('',#2484,#2485); +#2484 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2485 = VECTOR('',#2486,1.); +#2486 = DIRECTION('',(-0.,-1.)); +#2487 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2488 = PCURVE('',#1576,#2489); +#2489 = DEFINITIONAL_REPRESENTATION('',(#2490),#2494); +#2490 = LINE('',#2491,#2492); +#2491 = CARTESIAN_POINT('',(-0.,0.)); +#2492 = VECTOR('',#2493,1.); +#2493 = DIRECTION('',(-0.,-1.)); +#2494 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2495 = ORIENTED_EDGE('',*,*,#1555,.T.); +#2496 = ORIENTED_EDGE('',*,*,#2475,.F.); +#2497 = ADVANCED_FACE('',(#2498),#1611,.F.); +#2498 = FACE_BOUND('',#2499,.T.); +#2499 = EDGE_LOOP('',(#2500,#2528,#2549,#2550)); +#2500 = ORIENTED_EDGE('',*,*,#2501,.T.); +#2501 = EDGE_CURVE('',#2502,#2502,#2504,.T.); +#2502 = VERTEX_POINT('',#2503); +#2503 = CARTESIAN_POINT('',(-28.85,61.6,2.3)); +#2504 = SURFACE_CURVE('',#2505,(#2510,#2517),.PCURVE_S1.); +#2505 = CIRCLE('',#2506,1.15); +#2506 = AXIS2_PLACEMENT_3D('',#2507,#2508,#2509); +#2507 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2508 = DIRECTION('',(0.,0.,-1.)); +#2509 = DIRECTION('',(1.,0.,0.)); +#2510 = PCURVE('',#1611,#2511); +#2511 = DEFINITIONAL_REPRESENTATION('',(#2512),#2516); +#2512 = LINE('',#2513,#2514); +#2513 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2514 = VECTOR('',#2515,1.); +#2515 = DIRECTION('',(1.,-0.)); +#2516 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2517 = PCURVE('',#2322,#2518); +#2518 = DEFINITIONAL_REPRESENTATION('',(#2519),#2527); +#2519 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2520,#2521,#2522,#2523, +#2524,#2525,#2526),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2520 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2521 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2522 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2523 = CARTESIAN_POINT('',(-2.3,6.823758593797E-15)); +#2524 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2525 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2526 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2527 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2528 = ORIENTED_EDGE('',*,*,#2529,.T.); +#2529 = EDGE_CURVE('',#2502,#1591,#2530,.T.); +#2530 = SEAM_CURVE('',#2531,(#2535,#2542),.PCURVE_S1.); +#2531 = LINE('',#2532,#2533); +#2532 = CARTESIAN_POINT('',(-28.85,61.6,0.)); +#2533 = VECTOR('',#2534,1.); +#2534 = DIRECTION('',(0.,0.,1.)); +#2535 = PCURVE('',#1611,#2536); +#2536 = DEFINITIONAL_REPRESENTATION('',(#2537),#2541); +#2537 = LINE('',#2538,#2539); +#2538 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2539 = VECTOR('',#2540,1.); +#2540 = DIRECTION('',(-0.,-1.)); +#2541 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2542 = PCURVE('',#1611,#2543); +#2543 = DEFINITIONAL_REPRESENTATION('',(#2544),#2548); +#2544 = LINE('',#2545,#2546); +#2545 = CARTESIAN_POINT('',(-0.,0.)); +#2546 = VECTOR('',#2547,1.); +#2547 = DIRECTION('',(-0.,-1.)); +#2548 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2549 = ORIENTED_EDGE('',*,*,#1590,.T.); +#2550 = ORIENTED_EDGE('',*,*,#2529,.F.); +#2551 = ADVANCED_FACE('',(#2552,#2555),#2157,.F.); +#2552 = FACE_BOUND('',#2553,.F.); +#2553 = EDGE_LOOP('',(#2554)); +#2554 = ORIENTED_EDGE('',*,*,#2142,.T.); +#2555 = FACE_BOUND('',#2556,.F.); +#2556 = EDGE_LOOP('',(#2557)); +#2557 = ORIENTED_EDGE('',*,*,#2339,.T.); +#2558 = ADVANCED_FACE('',(#2559,#2562),#2212,.F.); +#2559 = FACE_BOUND('',#2560,.F.); +#2560 = EDGE_LOOP('',(#2561)); +#2561 = ORIENTED_EDGE('',*,*,#2197,.T.); +#2562 = FACE_BOUND('',#2563,.F.); +#2563 = EDGE_LOOP('',(#2564)); +#2564 = ORIENTED_EDGE('',*,*,#2393,.T.); +#2565 = ADVANCED_FACE('',(#2566,#2569),#2267,.F.); +#2566 = FACE_BOUND('',#2567,.F.); +#2567 = EDGE_LOOP('',(#2568)); +#2568 = ORIENTED_EDGE('',*,*,#2252,.T.); +#2569 = FACE_BOUND('',#2570,.F.); +#2570 = EDGE_LOOP('',(#2571)); +#2571 = ORIENTED_EDGE('',*,*,#2447,.T.); +#2572 = ADVANCED_FACE('',(#2573,#2576),#2322,.F.); +#2573 = FACE_BOUND('',#2574,.F.); +#2574 = EDGE_LOOP('',(#2575)); +#2575 = ORIENTED_EDGE('',*,*,#2307,.T.); +#2576 = FACE_BOUND('',#2577,.F.); +#2577 = EDGE_LOOP('',(#2578)); +#2578 = ORIENTED_EDGE('',*,*,#2501,.T.); +#2579 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#2583)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#2580,#2581,#2582)) REPRESENTATION_CONTEXT +('Context #1','3D Context with UNIT and UNCERTAINTY') ); +#2580 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#2581 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#2582 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#2583 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#2580, + 'distance_accuracy_value','confusion accuracy'); +#2584 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#2585,#2587); +#2585 = ( REPRESENTATION_RELATIONSHIP('','',#48,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#2586) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#2586 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#2587 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item', + #2588); +#2588 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','BottomCover','',#5,#43,$); +#2589 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#45)); +#2590 = SHAPE_DEFINITION_REPRESENTATION(#2591,#2597); +#2591 = PRODUCT_DEFINITION_SHAPE('','',#2592); +#2592 = PRODUCT_DEFINITION('design','',#2593,#2596); +#2593 = PRODUCT_DEFINITION_FORMATION('','',#2594); +#2594 = PRODUCT('Desk','Desk','',(#2595)); +#2595 = PRODUCT_CONTEXT('',#2,'mechanical'); +#2596 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#2597 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#2598),#20324); +#2598 = MANIFOLD_SOLID_BREP('',#2599); +#2599 = CLOSED_SHELL('',(#2600,#2722,#2798,#4400,#4472,#4521,#4620,#4844 + ,#4898,#4970,#5185,#5239,#5288,#5360,#5477,#5527,#5576,#5675,#5774, + #5825,#6004,#6054,#6927,#6974,#8349,#8376,#8465,#8492,#8539,#8566, + #8593,#9968,#10018,#10089,#10138,#10187,#10214,#10285,#10334,#10383, + #10410,#10460,#10510,#10581,#10630,#10679,#10706,#10756,#10806, + #10856,#10906,#10933,#10982,#11009,#11058,#11085,#11112,#11161, + #12316,#12682,#12782,#12882,#12982,#13105,#13192,#13279,#13326, + #13330,#13360,#13451,#13542,#13589,#13616,#13629,#13633,#13660, + #13664,#13755,#13846,#13893,#13920,#13933,#13937,#13941,#13945, + #13952,#14077,#14153,#14239,#14315,#14430,#14477,#14558,#14605, + #14715,#14791,#14862,#14909,#14926,#15008,#15090,#15172,#15254, + #15313,#15343,#15402,#15432,#15491,#15521,#15568,#15575,#15582, + #15609,#15636,#15663,#15754,#15789,#15880,#15915,#16006,#16041, + #16160,#16214,#16268,#16322,#16371,#16422,#16472,#16499,#16517, + #16650,#16657,#16667,#16674,#16721,#16768,#16815,#16862,#16909, + #16956,#17003,#17050,#17097,#17144,#17191,#17218,#17265,#17312, + #17359,#17386,#17433,#17480,#17507,#17554,#17601,#17648,#17695, + #17722,#17769,#17816,#17823,#17830,#17837,#17844,#17851,#17858, + #17865,#17872,#17879,#17886,#17893,#17900,#17907,#17914,#17921, + #17928,#17935,#17942,#17949,#17956,#17963,#17970,#18990,#19037, + #19084,#19131,#19178,#19225,#19272,#19319,#19366,#19413,#19460, + #19507,#19676,#19703,#19750,#19797,#19825,#19872,#19919,#19966, + #20013,#20042,#20069,#20116,#20163,#20170,#20177,#20184,#20192, + #20200,#20207,#20214,#20221,#20228,#20236,#20244,#20252,#20260, + #20268,#20275,#20282,#20289,#20296,#20303,#20310,#20317)); +#2600 = ADVANCED_FACE('',(#2601),#2616,.T.); +#2601 = FACE_BOUND('',#2602,.T.); +#2602 = EDGE_LOOP('',(#2603,#2639,#2667,#2696)); +#2603 = ORIENTED_EDGE('',*,*,#2604,.T.); +#2604 = EDGE_CURVE('',#2605,#2607,#2609,.T.); +#2605 = VERTEX_POINT('',#2606); +#2606 = CARTESIAN_POINT('',(-30.00000000007,58.6,4.499999999925)); +#2607 = VERTEX_POINT('',#2608); +#2608 = CARTESIAN_POINT('',(-27.00000000007,61.600000000005, + 4.499999999921)); +#2609 = SURFACE_CURVE('',#2610,(#2615,#2627),.PCURVE_S1.); +#2610 = CIRCLE('',#2611,3.); +#2611 = AXIS2_PLACEMENT_3D('',#2612,#2613,#2614); +#2612 = CARTESIAN_POINT('',(-30.00000000007,61.6,4.499999999772)); +#2613 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#2614 = DIRECTION('',(0.707106781188,-0.707106781186,9.726601044302E-13) + ); +#2615 = PCURVE('',#2616,#2621); +#2616 = CYLINDRICAL_SURFACE('',#2617,3.); +#2617 = AXIS2_PLACEMENT_3D('',#2618,#2619,#2620); +#2618 = CARTESIAN_POINT('',(-30.00000000007,61.6,38.5)); +#2619 = DIRECTION('',(-1.567230213877E-27,6.669143989382E-17,-1.)); +#2620 = DIRECTION('',(0.707106781188,-0.707106781186,-4.715796939706E-17 + )); +#2621 = DEFINITIONAL_REPRESENTATION('',(#2622),#2626); +#2622 = LINE('',#2623,#2624); +#2623 = CARTESIAN_POINT('',(12.566370614359,34.000000000242)); +#2624 = VECTOR('',#2625,1.); +#2625 = DIRECTION('',(-1.,-2.623604217243E-12)); +#2626 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2627 = PCURVE('',#2628,#2633); +#2628 = PLANE('',#2629); +#2629 = AXIS2_PLACEMENT_3D('',#2630,#2631,#2632); +#2630 = CARTESIAN_POINT('',(-85.55000000009,-64.59999999994, + 4.499999999772)); +#2631 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#2632 = DIRECTION('',(1.,-1.439064838363E-12,1.373715955813E-12)); +#2633 = DEFINITIONAL_REPRESENTATION('',(#2634),#2638); +#2634 = CIRCLE('',#2635,3.); +#2635 = AXIS2_PLACEMENT_2D('',#2636,#2637); +#2636 = CARTESIAN_POINT('',(55.54999999984,126.20000000002)); +#2637 = DIRECTION('',(0.707106781189,-0.707106781185)); +#2638 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2639 = ORIENTED_EDGE('',*,*,#2640,.T.); +#2640 = EDGE_CURVE('',#2607,#2641,#2643,.T.); +#2641 = VERTEX_POINT('',#2642); +#2642 = CARTESIAN_POINT('',(-27.00000000007,61.600000000005,36.5)); +#2643 = SURFACE_CURVE('',#2644,(#2648,#2655),.PCURVE_S1.); +#2644 = LINE('',#2645,#2646); +#2645 = CARTESIAN_POINT('',(-27.00000000007,61.600000000005,38.5)); +#2646 = VECTOR('',#2647,1.); +#2647 = DIRECTION('',(1.567230213877E-27,-6.669143989382E-17,1.)); +#2648 = PCURVE('',#2616,#2649); +#2649 = DEFINITIONAL_REPRESENTATION('',(#2650),#2654); +#2650 = LINE('',#2651,#2652); +#2651 = CARTESIAN_POINT('',(5.497787143782,0.)); +#2652 = VECTOR('',#2653,1.); +#2653 = DIRECTION('',(1.110223024622E-16,-1.)); +#2654 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2655 = PCURVE('',#2656,#2661); +#2656 = PLANE('',#2657); +#2657 = AXIS2_PLACEMENT_3D('',#2658,#2659,#2660); +#2658 = CARTESIAN_POINT('',(-27.00000000007,64.600000000005,38.5)); +#2659 = DIRECTION('',(1.,1.437813204818E-12,-1.471340380949E-27)); +#2660 = DIRECTION('',(1.437813204818E-12,-1.,-1.475342777831E-16)); +#2661 = DEFINITIONAL_REPRESENTATION('',(#2662),#2666); +#2662 = LINE('',#2663,#2664); +#2663 = CARTESIAN_POINT('',(3.,-4.426028333493E-16)); +#2664 = VECTOR('',#2665,1.); +#2665 = DIRECTION('',(-8.084283788926E-17,-1.)); +#2666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2667 = ORIENTED_EDGE('',*,*,#2668,.F.); +#2668 = EDGE_CURVE('',#2669,#2641,#2671,.T.); +#2669 = VERTEX_POINT('',#2670); +#2670 = CARTESIAN_POINT('',(-30.00000000007,58.6,36.5)); +#2671 = SURFACE_CURVE('',#2672,(#2677,#2684),.PCURVE_S1.); +#2672 = CIRCLE('',#2673,3.); +#2673 = AXIS2_PLACEMENT_3D('',#2674,#2675,#2676); +#2674 = CARTESIAN_POINT('',(-30.00000000007,61.6,36.5)); +#2675 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#2676 = DIRECTION('',(0.707106781188,-0.707106781186,1.992072365611E-15) + ); +#2677 = PCURVE('',#2616,#2678); +#2678 = DEFINITIONAL_REPRESENTATION('',(#2679),#2683); +#2679 = LINE('',#2680,#2681); +#2680 = CARTESIAN_POINT('',(12.566370614359,2.)); +#2681 = VECTOR('',#2682,1.); +#2682 = DIRECTION('',(-1.,4.52345554697E-15)); +#2683 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2684 = PCURVE('',#2685,#2690); +#2685 = PLANE('',#2686); +#2686 = AXIS2_PLACEMENT_3D('',#2687,#2688,#2689); +#2687 = CARTESIAN_POINT('',(-1.999999999991,-1.395816218918E-12,36.5)); +#2688 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#2689 = DIRECTION('',(1.,1.247844962247E-31,1.018942737707E-15)); +#2690 = DEFINITIONAL_REPRESENTATION('',(#2691),#2695); +#2691 = CIRCLE('',#2692,3.); +#2692 = AXIS2_PLACEMENT_2D('',#2693,#2694); +#2693 = CARTESIAN_POINT('',(-28.00000000008,61.600000000002)); +#2694 = DIRECTION('',(0.707106781188,-0.707106781186)); +#2695 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2696 = ORIENTED_EDGE('',*,*,#2697,.T.); +#2697 = EDGE_CURVE('',#2669,#2605,#2698,.T.); +#2698 = SURFACE_CURVE('',#2699,(#2703,#2710),.PCURVE_S1.); +#2699 = LINE('',#2700,#2701); +#2700 = CARTESIAN_POINT('',(-30.00000000007,58.6,38.5)); +#2701 = VECTOR('',#2702,1.); +#2702 = DIRECTION('',(-1.567230213877E-27,6.669143989382E-17,-1.)); +#2703 = PCURVE('',#2616,#2704); +#2704 = DEFINITIONAL_REPRESENTATION('',(#2705),#2709); +#2705 = LINE('',#2706,#2707); +#2706 = CARTESIAN_POINT('',(7.068583470577,0.)); +#2707 = VECTOR('',#2708,1.); +#2708 = DIRECTION('',(0.,1.)); +#2709 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2710 = PCURVE('',#2711,#2716); +#2711 = PLANE('',#2712); +#2712 = AXIS2_PLACEMENT_3D('',#2713,#2714,#2715); +#2713 = CARTESIAN_POINT('',(-27.00000000007,58.600000000005,38.5)); +#2714 = DIRECTION('',(1.443734394282E-12,-1.,-6.669143989382E-17)); +#2715 = DIRECTION('',(-1.,-1.443734394282E-12,4.998057065113E-29)); +#2716 = DEFINITIONAL_REPRESENTATION('',(#2717),#2721); +#2717 = LINE('',#2718,#2719); +#2718 = CARTESIAN_POINT('',(3.,3.482284472053E-28)); +#2719 = VECTOR('',#2720,1.); +#2720 = DIRECTION('',(1.420964917647E-27,1.)); +#2721 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2722 = ADVANCED_FACE('',(#2723),#2656,.T.); +#2723 = FACE_BOUND('',#2724,.T.); +#2724 = EDGE_LOOP('',(#2725,#2726,#2749,#2777)); +#2725 = ORIENTED_EDGE('',*,*,#2640,.F.); +#2726 = ORIENTED_EDGE('',*,*,#2727,.T.); +#2727 = EDGE_CURVE('',#2607,#2728,#2730,.T.); +#2728 = VERTEX_POINT('',#2729); +#2729 = CARTESIAN_POINT('',(-27.00000000007,62.599999999996, + 4.499999999852)); +#2730 = SURFACE_CURVE('',#2731,(#2735,#2742),.PCURVE_S1.); +#2731 = LINE('',#2732,#2733); +#2732 = CARTESIAN_POINT('',(-27.00000000007,63.100000000005, + 4.499999999921)); +#2733 = VECTOR('',#2734,1.); +#2734 = DIRECTION('',(-1.437813204818E-12,1.,-1.224646779457E-16)); +#2735 = PCURVE('',#2656,#2736); +#2736 = DEFINITIONAL_REPRESENTATION('',(#2737),#2741); +#2737 = LINE('',#2738,#2739); +#2738 = CARTESIAN_POINT('',(1.5,34.000000000079)); +#2739 = VECTOR('',#2740,1.); +#2740 = DIRECTION('',(-1.,2.699989557288E-16)); +#2741 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2742 = PCURVE('',#2628,#2743); +#2743 = DEFINITIONAL_REPRESENTATION('',(#2744),#2748); +#2744 = LINE('',#2745,#2746); +#2745 = CARTESIAN_POINT('',(58.549999999836,127.70000000003)); +#2746 = VECTOR('',#2747,1.); +#2747 = DIRECTION('',(-2.876878043181E-12,1.)); +#2748 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2749 = ORIENTED_EDGE('',*,*,#2750,.F.); +#2750 = EDGE_CURVE('',#2751,#2728,#2753,.T.); +#2751 = VERTEX_POINT('',#2752); +#2752 = CARTESIAN_POINT('',(-27.00000000007,62.599999999996,36.5)); +#2753 = SURFACE_CURVE('',#2754,(#2758,#2765),.PCURVE_S1.); +#2754 = LINE('',#2755,#2756); +#2755 = CARTESIAN_POINT('',(-27.00000000007,62.599999999996, + 28.324999999993)); +#2756 = VECTOR('',#2757,1.); +#2757 = DIRECTION('',(-1.295259047044E-27,-1.224646799147E-16,-1.)); +#2758 = PCURVE('',#2656,#2759); +#2759 = DEFINITIONAL_REPRESENTATION('',(#2760),#2764); +#2760 = LINE('',#2761,#2762); +#2761 = CARTESIAN_POINT('',(2.000000000009,10.175000000007)); +#2762 = VECTOR('',#2763,1.); +#2763 = DIRECTION('',(2.699989576978E-16,1.)); +#2764 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2765 = PCURVE('',#2766,#2771); +#2766 = PLANE('',#2767); +#2767 = AXIS2_PLACEMENT_3D('',#2768,#2769,#2770); +#2768 = CARTESIAN_POINT('',(-22.70000000001,62.599999999996, + 18.149999999987)); +#2769 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#2770 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#2771 = DEFINITIONAL_REPRESENTATION('',(#2772),#2776); +#2772 = LINE('',#2773,#2774); +#2773 = CARTESIAN_POINT('',(-10.175,-4.300000000061)); +#2774 = VECTOR('',#2775,1.); +#2775 = DIRECTION('',(1.,-1.229094387293E-27)); +#2776 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2777 = ORIENTED_EDGE('',*,*,#2778,.F.); +#2778 = EDGE_CURVE('',#2641,#2751,#2779,.T.); +#2779 = SURFACE_CURVE('',#2780,(#2784,#2791),.PCURVE_S1.); +#2780 = LINE('',#2781,#2782); +#2781 = CARTESIAN_POINT('',(-27.00000000003,32.299999999984,36.5)); +#2782 = VECTOR('',#2783,1.); +#2783 = DIRECTION('',(-1.437813204818E-12,1.,-1.798273018972E-15)); +#2784 = PCURVE('',#2656,#2785); +#2785 = DEFINITIONAL_REPRESENTATION('',(#2786),#2790); +#2786 = LINE('',#2787,#2788); +#2787 = CARTESIAN_POINT('',(32.300000000021,2.)); +#2788 = VECTOR('',#2789,1.); +#2789 = DIRECTION('',(-1.,1.945807296755E-15)); +#2790 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2791 = PCURVE('',#2685,#2792); +#2792 = DEFINITIONAL_REPRESENTATION('',(#2793),#2797); +#2793 = LINE('',#2794,#2795); +#2794 = CARTESIAN_POINT('',(-25.00000000004,32.299999999985)); +#2795 = VECTOR('',#2796,1.); +#2796 = DIRECTION('',(-1.437813204818E-12,1.)); +#2797 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2798 = ADVANCED_FACE('',(#2799,#4268,#4303,#4338,#4369),#2628,.F.); +#2799 = FACE_BOUND('',#2800,.T.); +#2800 = EDGE_LOOP('',(#2801,#2802,#2825,#2853,#2881,#2910,#2938,#2967, + #2995,#3023,#3051,#3084,#3112,#3145,#3173,#3202,#3230,#3259,#3287, + #3316,#3344,#3373,#3401,#3430,#3458,#3487,#3515,#3548,#3571,#3604, + #3632,#3660,#3688,#3717,#3740,#3769,#3797,#3825,#3853,#3881,#3909, + #3937,#3965,#3993,#4021,#4049,#4077,#4105,#4133,#4161,#4189,#4218, + #4246,#4267)); +#2801 = ORIENTED_EDGE('',*,*,#2604,.F.); +#2802 = ORIENTED_EDGE('',*,*,#2803,.F.); +#2803 = EDGE_CURVE('',#2804,#2605,#2806,.T.); +#2804 = VERTEX_POINT('',#2805); +#2805 = CARTESIAN_POINT('',(-31.,58.599999999999,4.5)); +#2806 = SURFACE_CURVE('',#2807,(#2811,#2818),.PCURVE_S1.); +#2807 = LINE('',#2808,#2809); +#2808 = CARTESIAN_POINT('',(-28.50000000009,58.600000000002, + 4.499999999923)); +#2809 = VECTOR('',#2810,1.); +#2810 = DIRECTION('',(1.,1.443734394282E-12,-1.373715955813E-12)); +#2811 = PCURVE('',#2628,#2812); +#2812 = DEFINITIONAL_REPRESENTATION('',(#2813),#2817); +#2813 = LINE('',#2814,#2815); +#2814 = CARTESIAN_POINT('',(57.049999999826,123.20000000003)); +#2815 = VECTOR('',#2816,1.); +#2816 = DIRECTION('',(1.,2.882799232645E-12)); +#2817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2818 = PCURVE('',#2711,#2819); +#2819 = DEFINITIONAL_REPRESENTATION('',(#2820),#2824); +#2820 = LINE('',#2821,#2822); +#2821 = CARTESIAN_POINT('',(1.500000000023,34.000000000077)); +#2822 = VECTOR('',#2823,1.); +#2823 = DIRECTION('',(-1.,1.373715955813E-12)); +#2824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2825 = ORIENTED_EDGE('',*,*,#2826,.T.); +#2826 = EDGE_CURVE('',#2804,#2827,#2829,.T.); +#2827 = VERTEX_POINT('',#2828); +#2828 = CARTESIAN_POINT('',(-31.,40.599999999996,4.5)); +#2829 = SURFACE_CURVE('',#2830,(#2834,#2841),.PCURVE_S1.); +#2830 = LINE('',#2831,#2832); +#2831 = CARTESIAN_POINT('',(-31.,32.299999999997,4.5)); +#2832 = VECTOR('',#2833,1.); +#2833 = DIRECTION('',(-5.892722207626E-15,-1.,1.224646799147E-16)); +#2834 = PCURVE('',#2628,#2835); +#2835 = DEFINITIONAL_REPRESENTATION('',(#2836),#2840); +#2836 = LINE('',#2837,#2838); +#2837 = CARTESIAN_POINT('',(54.549999999953,96.900000000024)); +#2838 = VECTOR('',#2839,1.); +#2839 = DIRECTION('',(1.433172116155E-12,-1.)); +#2840 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2841 = PCURVE('',#2842,#2847); +#2842 = PLANE('',#2843); +#2843 = AXIS2_PLACEMENT_3D('',#2844,#2845,#2846); +#2844 = CARTESIAN_POINT('',(-31.,64.599999999996,4.5)); +#2845 = DIRECTION('',(-1.,5.892722207626E-15,6.54430094124E-29)); +#2846 = DIRECTION('',(-5.892722207626E-15,-1.,1.224646799147E-16)); +#2847 = DEFINITIONAL_REPRESENTATION('',(#2848),#2852); +#2848 = LINE('',#2849,#2850); +#2849 = CARTESIAN_POINT('',(32.299999999999,1.025524555396E-14)); +#2850 = VECTOR('',#2851,1.); +#2851 = DIRECTION('',(1.,0.)); +#2852 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2853 = ORIENTED_EDGE('',*,*,#2854,.T.); +#2854 = EDGE_CURVE('',#2827,#2855,#2857,.T.); +#2855 = VERTEX_POINT('',#2856); +#2856 = CARTESIAN_POINT('',(-23.99999999994,40.599999999996,4.5)); +#2857 = SURFACE_CURVE('',#2858,(#2862,#2869),.PCURVE_S1.); +#2858 = LINE('',#2859,#2860); +#2859 = CARTESIAN_POINT('',(-17.49999999999,40.599999999996,4.5)); +#2860 = VECTOR('',#2861,1.); +#2861 = DIRECTION('',(1.,3.10862446895E-15,-6.654535645195E-29)); +#2862 = PCURVE('',#2628,#2863); +#2863 = DEFINITIONAL_REPRESENTATION('',(#2864),#2868); +#2864 = LINE('',#2865,#2866); +#2865 = CARTESIAN_POINT('',(68.049999999948,105.20000000004)); +#2866 = VECTOR('',#2867,1.); +#2867 = DIRECTION('',(1.,1.442173462832E-12)); +#2868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2869 = PCURVE('',#2870,#2875); +#2870 = PLANE('',#2871); +#2871 = AXIS2_PLACEMENT_3D('',#2872,#2873,#2874); +#2872 = CARTESIAN_POINT('',(-33.,40.599999999996,4.5)); +#2873 = DIRECTION('',(3.10862446895E-15,-1.,1.224646799147E-16)); +#2874 = DIRECTION('',(1.,3.10862446895E-15,-6.654535645195E-29)); +#2875 = DEFINITIONAL_REPRESENTATION('',(#2876),#2880); +#2876 = LINE('',#2877,#2878); +#2877 = CARTESIAN_POINT('',(15.500000000007,2.057195599503E-27)); +#2878 = VECTOR('',#2879,1.); +#2879 = DIRECTION('',(1.,0.)); +#2880 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2881 = ORIENTED_EDGE('',*,*,#2882,.F.); +#2882 = EDGE_CURVE('',#2883,#2855,#2885,.T.); +#2883 = VERTEX_POINT('',#2884); +#2884 = CARTESIAN_POINT('',(-20.99999999994,37.599999999996,4.5)); +#2885 = SURFACE_CURVE('',#2886,(#2891,#2898),.PCURVE_S1.); +#2886 = CIRCLE('',#2887,3.); +#2887 = AXIS2_PLACEMENT_3D('',#2888,#2889,#2890); +#2888 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996, + 4.499999999772)); +#2889 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#2890 = DIRECTION('',(0.707106781187,0.707106781187,9.700676311307E-13) + ); +#2891 = PCURVE('',#2628,#2892); +#2892 = DEFINITIONAL_REPRESENTATION('',(#2893),#2897); +#2893 = CIRCLE('',#2894,3.); +#2894 = AXIS2_PLACEMENT_2D('',#2895,#2896); +#2895 = CARTESIAN_POINT('',(61.550000000001,102.20000000003)); +#2896 = DIRECTION('',(0.707106781186,0.707106781188)); +#2897 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2898 = PCURVE('',#2899,#2904); +#2899 = CYLINDRICAL_SURFACE('',#2900,3.); +#2900 = AXIS2_PLACEMENT_3D('',#2901,#2902,#2903); +#2901 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996,4.5)); +#2902 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#2903 = DIRECTION('',(0.707106781187,0.707106781187,-8.65956056236E-17) + ); +#2904 = DEFINITIONAL_REPRESENTATION('',(#2905),#2909); +#2905 = LINE('',#2906,#2907); +#2906 = CARTESIAN_POINT('',(-8.881784197001E-16,-2.093543116644E-10)); +#2907 = VECTOR('',#2908,1.); +#2908 = DIRECTION('',(1.,-2.623604217243E-12)); +#2909 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2910 = ORIENTED_EDGE('',*,*,#2911,.T.); +#2911 = EDGE_CURVE('',#2883,#2912,#2914,.T.); +#2912 = VERTEX_POINT('',#2913); +#2913 = CARTESIAN_POINT('',(-20.99999999994,34.600000000031,4.5)); +#2914 = SURFACE_CURVE('',#2915,(#2919,#2926),.PCURVE_S1.); +#2915 = LINE('',#2916,#2917); +#2916 = CARTESIAN_POINT('',(-20.99999999994,19.299999999997,4.5)); +#2917 = VECTOR('',#2918,1.); +#2918 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#2919 = PCURVE('',#2628,#2920); +#2920 = DEFINITIONAL_REPRESENTATION('',(#2921),#2925); +#2921 = LINE('',#2922,#2923); +#2922 = CARTESIAN_POINT('',(64.550000000027,83.900000000038)); +#2923 = VECTOR('',#2924,1.); +#2924 = DIRECTION('',(1.439064838363E-12,-1.)); +#2925 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2926 = PCURVE('',#2927,#2932); +#2927 = PLANE('',#2928); +#2928 = AXIS2_PLACEMENT_3D('',#2929,#2930,#2931); +#2929 = CARTESIAN_POINT('',(-20.99999999994,38.599999999996,4.5)); +#2930 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#2931 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#2932 = DEFINITIONAL_REPRESENTATION('',(#2933),#2937); +#2933 = LINE('',#2934,#2935); +#2934 = CARTESIAN_POINT('',(19.299999999999,-2.363568322354E-15)); +#2935 = VECTOR('',#2936,1.); +#2936 = DIRECTION('',(1.,0.)); +#2937 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2938 = ORIENTED_EDGE('',*,*,#2939,.F.); +#2939 = EDGE_CURVE('',#2940,#2912,#2942,.T.); +#2940 = VERTEX_POINT('',#2941); +#2941 = CARTESIAN_POINT('',(-24.99999999994,30.600000000031,4.5)); +#2942 = SURFACE_CURVE('',#2943,(#2948,#2955),.PCURVE_S1.); +#2943 = CIRCLE('',#2944,4.); +#2944 = AXIS2_PLACEMENT_3D('',#2945,#2946,#2947); +#2945 = CARTESIAN_POINT('',(-24.99999999994,34.600000000031, + 4.499999999772)); +#2946 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#2947 = DIRECTION('',(0.707106781187,-0.707106781187,9.726601044288E-13) + ); +#2948 = PCURVE('',#2628,#2949); +#2949 = DEFINITIONAL_REPRESENTATION('',(#2950),#2954); +#2950 = CIRCLE('',#2951,4.); +#2951 = AXIS2_PLACEMENT_2D('',#2952,#2953); +#2952 = CARTESIAN_POINT('',(60.550000000005,99.200000000067)); +#2953 = DIRECTION('',(0.707106781188,-0.707106781186)); +#2954 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2955 = PCURVE('',#2956,#2961); +#2956 = CYLINDRICAL_SURFACE('',#2957,4.); +#2957 = AXIS2_PLACEMENT_3D('',#2958,#2959,#2960); +#2958 = CARTESIAN_POINT('',(-24.99999999994,34.600000000031,4.5)); +#2959 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#2960 = DIRECTION('',(0.707106781187,-0.707106781187,8.65956056235E-17) + ); +#2961 = DEFINITIONAL_REPRESENTATION('',(#2962),#2966); +#2962 = LINE('',#2963,#2964); +#2963 = CARTESIAN_POINT('',(6.28318530718,2.471480797794E-10)); +#2964 = VECTOR('',#2965,1.); +#2965 = DIRECTION('',(-1.,-3.501154593355E-12)); +#2966 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2967 = ORIENTED_EDGE('',*,*,#2968,.T.); +#2968 = EDGE_CURVE('',#2940,#2969,#2971,.T.); +#2969 = VERTEX_POINT('',#2970); +#2970 = CARTESIAN_POINT('',(-75.30000000002,30.600000000031,4.5)); +#2971 = SURFACE_CURVE('',#2972,(#2976,#2983),.PCURVE_S1.); +#2972 = LINE('',#2973,#2974); +#2973 = CARTESIAN_POINT('',(-12.49999999997,30.600000000031,4.5)); +#2974 = VECTOR('',#2975,1.); +#2975 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#2976 = PCURVE('',#2628,#2977); +#2977 = DEFINITIONAL_REPRESENTATION('',(#2978),#2982); +#2978 = LINE('',#2979,#2980); +#2979 = CARTESIAN_POINT('',(73.04999999999,95.200000000085)); +#2980 = VECTOR('',#2981,1.); +#2981 = DIRECTION('',(-1.,-1.439064838363E-12)); +#2982 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2983 = PCURVE('',#2984,#2989); +#2984 = PLANE('',#2985); +#2985 = AXIS2_PLACEMENT_3D('',#2986,#2987,#2988); +#2986 = CARTESIAN_POINT('',(-22.99999999994,30.600000000031,4.5)); +#2987 = DIRECTION('',(4.45098715844E-61,1.,-1.224646799147E-16)); +#2988 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#2989 = DEFINITIONAL_REPRESENTATION('',(#2990),#2994); +#2990 = LINE('',#2991,#2992); +#2991 = CARTESIAN_POINT('',(-10.49999999997,1.389457854776E-27)); +#2992 = VECTOR('',#2993,1.); +#2993 = DIRECTION('',(1.,0.)); +#2994 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2995 = ORIENTED_EDGE('',*,*,#2996,.F.); +#2996 = EDGE_CURVE('',#2997,#2969,#2999,.T.); +#2997 = VERTEX_POINT('',#2998); +#2998 = CARTESIAN_POINT('',(-75.30000000002,35.600000000034,4.5)); +#2999 = SURFACE_CURVE('',#3000,(#3004,#3011),.PCURVE_S1.); +#3000 = LINE('',#3001,#3002); +#3001 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,4.5)); +#3002 = VECTOR('',#3003,1.); +#3003 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#3004 = PCURVE('',#2628,#3005); +#3005 = DEFINITIONAL_REPRESENTATION('',(#3006),#3010); +#3006 = LINE('',#3007,#3008); +#3007 = CARTESIAN_POINT('',(10.250000000071,34.299999999923)); +#3008 = VECTOR('',#3009,1.); +#3009 = DIRECTION('',(2.232560086906E-12,-1.)); +#3010 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3011 = PCURVE('',#3012,#3017); +#3012 = PLANE('',#3013); +#3013 = AXIS2_PLACEMENT_3D('',#3014,#3015,#3016); +#3014 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,38.5)); +#3015 = DIRECTION('',(-1.,-7.934952485434E-13,1.630339950124E-28)); +#3016 = DIRECTION('',(7.199750894054E-28,-1.112809542387E-15,-1.)); +#3017 = DEFINITIONAL_REPRESENTATION('',(#3018),#3022); +#3018 = LINE('',#3019,#3020); +#3019 = CARTESIAN_POINT('',(34.,-3.073009708355E-14)); +#3020 = VECTOR('',#3021,1.); +#3021 = DIRECTION('',(-6.854634765848E-16,1.)); +#3022 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3023 = ORIENTED_EDGE('',*,*,#3024,.F.); +#3024 = EDGE_CURVE('',#3025,#2997,#3027,.T.); +#3025 = VERTEX_POINT('',#3026); +#3026 = CARTESIAN_POINT('',(-23.99999999994,35.599999999997,4.5)); +#3027 = SURFACE_CURVE('',#3028,(#3032,#3039),.PCURVE_S1.); +#3028 = LINE('',#3029,#3030); +#3029 = CARTESIAN_POINT('',(-36.07499999995,35.600000000005,4.5)); +#3030 = VECTOR('',#3031,1.); +#3031 = DIRECTION('',(-1.,7.174263050427E-13,-1.51390392414E-27)); +#3032 = PCURVE('',#2628,#3033); +#3033 = DEFINITIONAL_REPRESENTATION('',(#3034),#3038); +#3034 = LINE('',#3035,#3036); +#3035 = CARTESIAN_POINT('',(49.474999999995,100.20000000002)); +#3036 = VECTOR('',#3037,1.); +#3037 = DIRECTION('',(-1.,-7.216385333204E-13)); +#3038 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3039 = PCURVE('',#3040,#3045); +#3040 = PLANE('',#3041); +#3041 = AXIS2_PLACEMENT_3D('',#3042,#3043,#3044); +#3042 = CARTESIAN_POINT('',(-49.15,35.600000000015,21.5)); +#3043 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#3044 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#3045 = DEFINITIONAL_REPRESENTATION('',(#3046),#3050); +#3046 = LINE('',#3047,#3048); +#3047 = CARTESIAN_POINT('',(-17.,13.075000000052)); +#3048 = VECTOR('',#3049,1.); +#3049 = DIRECTION('',(-8.785619229743E-28,-1.)); +#3050 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3051 = ORIENTED_EDGE('',*,*,#3052,.F.); +#3052 = EDGE_CURVE('',#3053,#3025,#3055,.T.); +#3053 = VERTEX_POINT('',#3054); +#3054 = CARTESIAN_POINT('',(-22.99999999994,36.599999999997,4.5)); +#3055 = SURFACE_CURVE('',#3056,(#3061,#3072),.PCURVE_S1.); +#3056 = CIRCLE('',#3057,1.); +#3057 = AXIS2_PLACEMENT_3D('',#3058,#3059,#3060); +#3058 = CARTESIAN_POINT('',(-23.99999999994,36.599999999997, + 4.499999999772)); +#3059 = DIRECTION('',(1.373715955813E-12,-1.833155449138E-15,-1.)); +#3060 = DIRECTION('',(0.707106781186,-0.707106781187,9.726601044284E-13) + ); +#3061 = PCURVE('',#2628,#3062); +#3062 = DEFINITIONAL_REPRESENTATION('',(#3063),#3071); +#3063 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#3064,#3065,#3066,#3067, +#3068,#3069,#3070),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#3064 = CARTESIAN_POINT('',(62.257106781189,100.49289321884)); +#3065 = CARTESIAN_POINT('',(61.032361909799,99.268148347455)); +#3066 = CARTESIAN_POINT('',(60.584074173713,100.94118095493)); +#3067 = CARTESIAN_POINT('',(60.135786437627,102.6142135624)); +#3068 = CARTESIAN_POINT('',(61.808819045103,102.16592582632)); +#3069 = CARTESIAN_POINT('',(63.48185165258,101.71763809024)); +#3070 = CARTESIAN_POINT('',(62.257106781189,100.49289321884)); +#3071 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3072 = PCURVE('',#3073,#3078); +#3073 = CYLINDRICAL_SURFACE('',#3074,1.); +#3074 = AXIS2_PLACEMENT_3D('',#3075,#3076,#3077); +#3075 = CARTESIAN_POINT('',(-23.99999999994,36.599999999997,13.)); +#3076 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#3077 = DIRECTION('',(0.707106781186,-0.707106781187,6.914161266403E-16) + ); +#3078 = DEFINITIONAL_REPRESENTATION('',(#3079),#3083); +#3079 = LINE('',#3080,#3081); +#3080 = CARTESIAN_POINT('',(6.28318530718,-8.500000000222)); +#3081 = VECTOR('',#3082,1.); +#3082 = DIRECTION('',(-1.,-8.775503761118E-13)); +#3083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3084 = ORIENTED_EDGE('',*,*,#3085,.F.); +#3085 = EDGE_CURVE('',#3086,#3053,#3088,.T.); +#3086 = VERTEX_POINT('',#3087); +#3087 = CARTESIAN_POINT('',(-22.99999999994,37.599999999996,4.5)); +#3088 = SURFACE_CURVE('',#3089,(#3093,#3100),.PCURVE_S1.); +#3089 = LINE('',#3090,#3091); +#3090 = CARTESIAN_POINT('',(-22.99999999994,-35.59999999999,4.5)); +#3091 = VECTOR('',#3092,1.); +#3092 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#3093 = PCURVE('',#2628,#3094); +#3094 = DEFINITIONAL_REPRESENTATION('',(#3095),#3099); +#3095 = LINE('',#3096,#3097); +#3096 = CARTESIAN_POINT('',(62.550000000106,29.000000000039)); +#3097 = VECTOR('',#3098,1.); +#3098 = DIRECTION('',(1.439064838363E-12,-1.)); +#3099 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3100 = PCURVE('',#3101,#3106); +#3101 = PLANE('',#3102); +#3102 = AXIS2_PLACEMENT_3D('',#3103,#3104,#3105); +#3103 = CARTESIAN_POINT('',(-22.99999999994,38.599999999996,4.5)); +#3104 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#3105 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#3106 = DEFINITIONAL_REPRESENTATION('',(#3107),#3111); +#3107 = LINE('',#3108,#3109); +#3108 = CARTESIAN_POINT('',(74.199999999995,-9.086879249673E-15)); +#3109 = VECTOR('',#3110,1.); +#3110 = DIRECTION('',(1.,0.)); +#3111 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3112 = ORIENTED_EDGE('',*,*,#3113,.F.); +#3113 = EDGE_CURVE('',#3114,#3086,#3116,.T.); +#3114 = VERTEX_POINT('',#3115); +#3115 = CARTESIAN_POINT('',(-23.99999999994,38.599999999996,4.5)); +#3116 = SURFACE_CURVE('',#3117,(#3122,#3133),.PCURVE_S1.); +#3117 = CIRCLE('',#3118,1.); +#3118 = AXIS2_PLACEMENT_3D('',#3119,#3120,#3121); +#3119 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996, + 4.499999999772)); +#3120 = DIRECTION('',(1.373715955813E-12,-1.833155449138E-15,-1.)); +#3121 = DIRECTION('',(0.707106781187,0.707106781187,9.700676311307E-13) + ); +#3122 = PCURVE('',#2628,#3123); +#3123 = DEFINITIONAL_REPRESENTATION('',(#3124),#3132); +#3124 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#3125,#3126,#3127,#3128, +#3129,#3130,#3131),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#3125 = CARTESIAN_POINT('',(62.257106781186,102.90710678122)); +#3126 = CARTESIAN_POINT('',(63.481851652579,101.68236190983)); +#3127 = CARTESIAN_POINT('',(61.808819045104,101.23407417374)); +#3128 = CARTESIAN_POINT('',(60.135786437629,100.78578643765)); +#3129 = CARTESIAN_POINT('',(60.584074173711,102.45881904513)); +#3130 = CARTESIAN_POINT('',(61.032361909793,104.13185165261)); +#3131 = CARTESIAN_POINT('',(62.257106781186,102.90710678122)); +#3132 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3133 = PCURVE('',#3134,#3139); +#3134 = CYLINDRICAL_SURFACE('',#3135,1.); +#3135 = AXIS2_PLACEMENT_3D('',#3136,#3137,#3138); +#3136 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996,4.5)); +#3137 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#3138 = DIRECTION('',(0.707106781187,0.707106781187,-8.65956056236E-17) + ); +#3139 = DEFINITIONAL_REPRESENTATION('',(#3140),#3144); +#3140 = LINE('',#3141,#3142); +#3141 = CARTESIAN_POINT('',(6.28318530718,-2.327240622435E-10)); +#3142 = VECTOR('',#3143,1.); +#3143 = DIRECTION('',(-1.,8.775503761122E-13)); +#3144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3145 = ORIENTED_EDGE('',*,*,#3146,.T.); +#3146 = EDGE_CURVE('',#3114,#3147,#3149,.T.); +#3147 = VERTEX_POINT('',#3148); +#3148 = CARTESIAN_POINT('',(-30.,38.599999999996,4.5)); +#3149 = SURFACE_CURVE('',#3150,(#3154,#3161),.PCURVE_S1.); +#3150 = LINE('',#3151,#3152); +#3151 = CARTESIAN_POINT('',(-23.,38.599999999996,4.5)); +#3152 = VECTOR('',#3153,1.); +#3153 = DIRECTION('',(-1.,-3.10862446895E-15,6.654535645195E-29)); +#3154 = PCURVE('',#2628,#3155); +#3155 = DEFINITIONAL_REPRESENTATION('',(#3156),#3160); +#3156 = LINE('',#3157,#3158); +#3157 = CARTESIAN_POINT('',(62.549999999944,103.20000000003)); +#3158 = VECTOR('',#3159,1.); +#3159 = DIRECTION('',(-1.,-1.442173462832E-12)); +#3160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3161 = PCURVE('',#3162,#3167); +#3162 = PLANE('',#3163); +#3163 = AXIS2_PLACEMENT_3D('',#3164,#3165,#3166); +#3164 = CARTESIAN_POINT('',(-33.,38.599999999996,4.5)); +#3165 = DIRECTION('',(3.10862446895E-15,-1.,1.224646799147E-16)); +#3166 = DIRECTION('',(1.,3.10862446895E-15,-6.654535645195E-29)); +#3167 = DEFINITIONAL_REPRESENTATION('',(#3168),#3172); +#3168 = LINE('',#3169,#3170); +#3169 = CARTESIAN_POINT('',(10.,1.326773850576E-27)); +#3170 = VECTOR('',#3171,1.); +#3171 = DIRECTION('',(-1.,0.)); +#3172 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3173 = ORIENTED_EDGE('',*,*,#3174,.F.); +#3174 = EDGE_CURVE('',#3175,#3147,#3177,.T.); +#3175 = VERTEX_POINT('',#3176); +#3176 = CARTESIAN_POINT('',(-33.,41.599999999996,4.499999999844)); +#3177 = SURFACE_CURVE('',#3178,(#3183,#3190),.PCURVE_S1.); +#3178 = CIRCLE('',#3179,3.); +#3179 = AXIS2_PLACEMENT_3D('',#3180,#3181,#3182); +#3180 = CARTESIAN_POINT('',(-30.,41.599999999996,4.499999999772)); +#3181 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3182 = DIRECTION('',(-0.707106781187,-0.707106781187, + -9.700676311307E-13)); +#3183 = PCURVE('',#2628,#3184); +#3184 = DEFINITIONAL_REPRESENTATION('',(#3185),#3189); +#3185 = CIRCLE('',#3186,3.); +#3186 = AXIS2_PLACEMENT_2D('',#3187,#3188); +#3187 = CARTESIAN_POINT('',(55.549999999939,106.20000000002)); +#3188 = DIRECTION('',(-0.707106781186,-0.707106781188)); +#3189 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3190 = PCURVE('',#3191,#3196); +#3191 = CYLINDRICAL_SURFACE('',#3192,3.); +#3192 = AXIS2_PLACEMENT_3D('',#3193,#3194,#3195); +#3193 = CARTESIAN_POINT('',(-30.,41.599999999996,21.5)); +#3194 = DIRECTION('',(6.650456067787E-29,1.224646799147E-16,1.)); +#3195 = DIRECTION('',(-0.707106781187,-0.707106781187,8.65956056236E-17) + ); +#3196 = DEFINITIONAL_REPRESENTATION('',(#3197),#3201); +#3197 = LINE('',#3198,#3199); +#3198 = CARTESIAN_POINT('',(-8.881784197001E-16,-17.00000000024)); +#3199 = VECTOR('',#3200,1.); +#3200 = DIRECTION('',(1.,2.623604217243E-12)); +#3201 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3202 = ORIENTED_EDGE('',*,*,#3203,.F.); +#3203 = EDGE_CURVE('',#3204,#3175,#3206,.T.); +#3204 = VERTEX_POINT('',#3205); +#3205 = CARTESIAN_POINT('',(-33.,61.599999999996,4.499999999844)); +#3206 = SURFACE_CURVE('',#3207,(#3211,#3218),.PCURVE_S1.); +#3207 = LINE('',#3208,#3209); +#3208 = CARTESIAN_POINT('',(-33.,64.599999999996,4.499999999844)); +#3209 = VECTOR('',#3210,1.); +#3210 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#3211 = PCURVE('',#2628,#3212); +#3212 = DEFINITIONAL_REPRESENTATION('',(#3213),#3217); +#3213 = LINE('',#3214,#3215); +#3214 = CARTESIAN_POINT('',(52.549999999906,129.20000000002)); +#3215 = VECTOR('',#3216,1.); +#3216 = DIRECTION('',(1.443505730462E-12,-1.)); +#3217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3218 = PCURVE('',#3219,#3224); +#3219 = PLANE('',#3220); +#3220 = AXIS2_PLACEMENT_3D('',#3221,#3222,#3223); +#3221 = CARTESIAN_POINT('',(-33.,64.599999999996,38.5)); +#3222 = DIRECTION('',(-1.,-4.440892098501E-15,6.704841310725E-29)); +#3223 = DIRECTION('',(-5.990332689509E-29,-1.608930380131E-15,-1.)); +#3224 = DEFINITIONAL_REPRESENTATION('',(#3225),#3229); +#3225 = LINE('',#3226,#3227); +#3226 = CARTESIAN_POINT('',(34.000000000156,-4.049277820949E-14)); +#3227 = VECTOR('',#3228,1.); +#3228 = DIRECTION('',(1.486465700216E-15,1.)); +#3229 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3230 = ORIENTED_EDGE('',*,*,#3231,.F.); +#3231 = EDGE_CURVE('',#3232,#3204,#3234,.T.); +#3232 = VERTEX_POINT('',#3233); +#3233 = CARTESIAN_POINT('',(-30.,64.599999999996,4.499999999848)); +#3234 = SURFACE_CURVE('',#3235,(#3240,#3247),.PCURVE_S1.); +#3235 = CIRCLE('',#3236,3.); +#3236 = AXIS2_PLACEMENT_3D('',#3237,#3238,#3239); +#3237 = CARTESIAN_POINT('',(-30.,61.599999999996,4.499999999772)); +#3238 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3239 = DIRECTION('',(-0.707106781187,0.707106781187,-9.726601044288E-13 + )); +#3240 = PCURVE('',#2628,#3241); +#3241 = DEFINITIONAL_REPRESENTATION('',(#3242),#3246); +#3242 = CIRCLE('',#3243,3.); +#3243 = AXIS2_PLACEMENT_2D('',#3244,#3245); +#3244 = CARTESIAN_POINT('',(55.549999999911,126.20000000002)); +#3245 = DIRECTION('',(-0.707106781188,0.707106781186)); +#3246 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3247 = PCURVE('',#3248,#3253); +#3248 = CYLINDRICAL_SURFACE('',#3249,3.); +#3249 = AXIS2_PLACEMENT_3D('',#3250,#3251,#3252); +#3250 = CARTESIAN_POINT('',(-30.,61.599999999996,28.324999999993)); +#3251 = DIRECTION('',(-5.874323732859E-29,-1.870159327101E-15,-1.)); +#3252 = DIRECTION('',(-0.707106781187,0.707106781187,-1.322402342092E-15 + )); +#3253 = DEFINITIONAL_REPRESENTATION('',(#3254),#3258); +#3254 = LINE('',#3255,#3256); +#3255 = CARTESIAN_POINT('',(6.28318530718,23.825000000207)); +#3256 = VECTOR('',#3257,1.); +#3257 = DIRECTION('',(-1.,2.623604217243E-12)); +#3258 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3259 = ORIENTED_EDGE('',*,*,#3260,.F.); +#3260 = EDGE_CURVE('',#3261,#3232,#3263,.T.); +#3261 = VERTEX_POINT('',#3262); +#3262 = CARTESIAN_POINT('',(26.000000000112,64.599999999996, + 4.499999999925)); +#3263 = SURFACE_CURVE('',#3264,(#3268,#3275),.PCURVE_S1.); +#3264 = LINE('',#3265,#3266); +#3265 = CARTESIAN_POINT('',(64.449999999996,64.599999999996, + 4.499999999978)); +#3266 = VECTOR('',#3267,1.); +#3267 = DIRECTION('',(-1.,-4.212228277711E-15,-1.373715955813E-12)); +#3268 = PCURVE('',#2628,#3269); +#3269 = DEFINITIONAL_REPRESENTATION('',(#3270),#3274); +#3270 = LINE('',#3271,#3272); +#3271 = CARTESIAN_POINT('',(149.9999999999,129.20000000016)); +#3272 = VECTOR('',#3273,1.); +#3273 = DIRECTION('',(-1.,-1.443277066641E-12)); +#3274 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3275 = PCURVE('',#3276,#3281); +#3276 = PLANE('',#3277); +#3277 = AXIS2_PLACEMENT_3D('',#3278,#3279,#3280); +#3278 = CARTESIAN_POINT('',(-22.70000000001,64.599999999996, + 18.149999999987)); +#3279 = DIRECTION('',(-4.212228277709E-15,1.,-1.870159327101E-15)); +#3280 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#3281 = DEFINITIONAL_REPRESENTATION('',(#3282),#3286); +#3282 = LINE('',#3283,#3284); +#3283 = CARTESIAN_POINT('',(-87.15000000001,-13.65)); +#3284 = VECTOR('',#3285,1.); +#3285 = DIRECTION('',(1.,-1.373715955813E-12)); +#3286 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3287 = ORIENTED_EDGE('',*,*,#3288,.F.); +#3288 = EDGE_CURVE('',#3289,#3261,#3291,.T.); +#3289 = VERTEX_POINT('',#3290); +#3290 = CARTESIAN_POINT('',(29.000000000023,61.599999999992, + 4.499999999929)); +#3291 = SURFACE_CURVE('',#3292,(#3297,#3304),.PCURVE_S1.); +#3292 = CIRCLE('',#3293,3.); +#3293 = AXIS2_PLACEMENT_3D('',#3294,#3295,#3296); +#3294 = CARTESIAN_POINT('',(26.000000000112,61.599999999996, + 4.499999999772)); +#3295 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3296 = DIRECTION('',(0.707106781187,0.707106781186,9.700676311314E-13) + ); +#3297 = PCURVE('',#2628,#3298); +#3298 = DEFINITIONAL_REPRESENTATION('',(#3299),#3303); +#3299 = CIRCLE('',#3300,3.); +#3300 = AXIS2_PLACEMENT_2D('',#3301,#3302); +#3301 = CARTESIAN_POINT('',(111.55000000002,126.2000000001)); +#3302 = DIRECTION('',(0.707106781186,0.707106781187)); +#3303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3304 = PCURVE('',#3305,#3310); +#3305 = CYLINDRICAL_SURFACE('',#3306,3.); +#3306 = AXIS2_PLACEMENT_3D('',#3307,#3308,#3309); +#3307 = CARTESIAN_POINT('',(26.000000000112,61.599999999996, + 11.324999999993)); +#3308 = DIRECTION('',(-1.347058560847E-27,-1.870159327101E-15,-1.)); +#3309 = DIRECTION('',(0.707106781187,0.707106781186,-1.322402342092E-15) + ); +#3310 = DEFINITIONAL_REPRESENTATION('',(#3311),#3315); +#3311 = LINE('',#3312,#3313); +#3312 = CARTESIAN_POINT('',(12.566370614359,6.825000000203)); +#3313 = VECTOR('',#3314,1.); +#3314 = DIRECTION('',(-1.,2.62360421724E-12)); +#3315 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3316 = ORIENTED_EDGE('',*,*,#3317,.F.); +#3317 = EDGE_CURVE('',#3318,#3289,#3320,.T.); +#3318 = VERTEX_POINT('',#3319); +#3319 = CARTESIAN_POINT('',(29.000000000024,-61.60000000011, + 4.499999999929)); +#3320 = SURFACE_CURVE('',#3321,(#3325,#3332),.PCURVE_S1.); +#3321 = LINE('',#3322,#3323); +#3322 = CARTESIAN_POINT('',(29.000000000023,64.599999999996, + 4.499999999929)); +#3323 = VECTOR('',#3324,1.); +#3324 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#3325 = PCURVE('',#2628,#3326); +#3326 = DEFINITIONAL_REPRESENTATION('',(#3327),#3331); +#3327 = LINE('',#3328,#3329); +#3328 = CARTESIAN_POINT('',(114.54999999993,129.2000000001)); +#3329 = VECTOR('',#3330,1.); +#3330 = DIRECTION('',(-1.443505730462E-12,1.)); +#3331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3332 = PCURVE('',#3333,#3338); +#3333 = PLANE('',#3334); +#3334 = AXIS2_PLACEMENT_3D('',#3335,#3336,#3337); +#3335 = CARTESIAN_POINT('',(28.99999999993,-64.60000000011,4.5)); +#3336 = DIRECTION('',(-1.,1.439293502184E-12,-1.344649606698E-27)); +#3337 = DIRECTION('',(-8.456613066457E-28,3.466897469453E-16,1.)); +#3338 = DEFINITIONAL_REPRESENTATION('',(#3339),#3343); +#3339 = LINE('',#3340,#3341); +#3340 = CARTESIAN_POINT('',(-7.078210758526E-11,129.2000000001)); +#3341 = VECTOR('',#3342,1.); +#3342 = DIRECTION('',(2.242250670306E-16,1.)); +#3343 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3344 = ORIENTED_EDGE('',*,*,#3345,.F.); +#3345 = EDGE_CURVE('',#3346,#3318,#3348,.T.); +#3346 = VERTEX_POINT('',#3347); +#3347 = CARTESIAN_POINT('',(25.99999999993,-64.6000000001,4.499999999925 + )); +#3348 = SURFACE_CURVE('',#3349,(#3354,#3361),.PCURVE_S1.); +#3349 = CIRCLE('',#3350,3.); +#3350 = AXIS2_PLACEMENT_3D('',#3351,#3352,#3353); +#3351 = CARTESIAN_POINT('',(25.999999999935,-61.6000000001, + 4.499999999772)); +#3352 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3353 = DIRECTION('',(0.707106781186,-0.707106781188,9.726601044274E-13) + ); +#3354 = PCURVE('',#2628,#3355); +#3355 = DEFINITIONAL_REPRESENTATION('',(#3356),#3360); +#3356 = CIRCLE('',#3357,3.); +#3357 = AXIS2_PLACEMENT_2D('',#3358,#3359); +#3358 = CARTESIAN_POINT('',(111.55000000002,3.)); +#3359 = DIRECTION('',(0.707106781187,-0.707106781187)); +#3360 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3361 = PCURVE('',#3362,#3367); +#3362 = CYLINDRICAL_SURFACE('',#3363,3.); +#3363 = AXIS2_PLACEMENT_3D('',#3364,#3365,#3366); +#3364 = CARTESIAN_POINT('',(25.999999999935,-61.6000000001, + 11.324999999994)); +#3365 = DIRECTION('',(1.221646432603E-27,-8.54607999747E-17,-1.)); +#3366 = DIRECTION('',(0.707106781186,-0.707106781188,6.042991118869E-17) + ); +#3367 = DEFINITIONAL_REPRESENTATION('',(#3368),#3372); +#3368 = LINE('',#3369,#3370); +#3369 = CARTESIAN_POINT('',(12.566370614359,6.825000000236)); +#3370 = VECTOR('',#3371,1.); +#3371 = DIRECTION('',(-1.,-2.623604217243E-12)); +#3372 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3373 = ORIENTED_EDGE('',*,*,#3374,.T.); +#3374 = EDGE_CURVE('',#3346,#3375,#3377,.T.); +#3375 = VERTEX_POINT('',#3376); +#3376 = CARTESIAN_POINT('',(-30.00000000009,-64.60000000002, + 4.499999999848)); +#3377 = SURFACE_CURVE('',#3378,(#3382,#3389),.PCURVE_S1.); +#3378 = LINE('',#3379,#3380); +#3379 = CARTESIAN_POINT('',(64.449999999904,-64.60000000016, + 4.499999999978)); +#3380 = VECTOR('',#3381,1.); +#3381 = DIRECTION('',(-1.,1.439064838363E-12,-1.373715955813E-12)); +#3382 = PCURVE('',#2628,#3383); +#3383 = DEFINITIONAL_REPRESENTATION('',(#3384),#3388); +#3384 = LINE('',#3385,#3386); +#3385 = CARTESIAN_POINT('',(150.,-4.578993360615E-14)); +#3386 = VECTOR('',#3387,1.); +#3387 = DIRECTION('',(-1.,-1.070942053239E-28)); +#3388 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3389 = PCURVE('',#3390,#3395); +#3390 = PLANE('',#3391); +#3391 = AXIS2_PLACEMENT_3D('',#3392,#3393,#3394); +#3392 = CARTESIAN_POINT('',(-22.7000000001,-64.60000000003, + 18.149999999987)); +#3393 = DIRECTION('',(1.439064838363E-12,1.,-8.54607999747E-17)); +#3394 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#3395 = DEFINITIONAL_REPRESENTATION('',(#3396),#3400); +#3396 = LINE('',#3397,#3398); +#3397 = CARTESIAN_POINT('',(-87.15000000001,-13.65)); +#3398 = VECTOR('',#3399,1.); +#3399 = DIRECTION('',(1.,-1.373715955813E-12)); +#3400 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3401 = ORIENTED_EDGE('',*,*,#3402,.F.); +#3402 = EDGE_CURVE('',#3403,#3375,#3405,.T.); +#3403 = VERTEX_POINT('',#3404); +#3404 = CARTESIAN_POINT('',(-33.00000000009,-61.60000000002, + 4.499999999844)); +#3405 = SURFACE_CURVE('',#3406,(#3411,#3418),.PCURVE_S1.); +#3406 = CIRCLE('',#3407,3.); +#3407 = AXIS2_PLACEMENT_3D('',#3408,#3409,#3410); +#3408 = CARTESIAN_POINT('',(-30.00000000009,-61.60000000002, + 4.499999999772)); +#3409 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3410 = DIRECTION('',(-0.707106781188,-0.707106781186, + -9.700676311321E-13)); +#3411 = PCURVE('',#2628,#3412); +#3412 = DEFINITIONAL_REPRESENTATION('',(#3413),#3417); +#3413 = CIRCLE('',#3414,3.); +#3414 = AXIS2_PLACEMENT_2D('',#3415,#3416); +#3415 = CARTESIAN_POINT('',(55.549999999999,3.)); +#3416 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#3417 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3418 = PCURVE('',#3419,#3424); +#3419 = CYLINDRICAL_SURFACE('',#3420,3.); +#3420 = AXIS2_PLACEMENT_3D('',#3421,#3422,#3423); +#3421 = CARTESIAN_POINT('',(-30.00000000009,-61.60000000002, + 28.324999999994)); +#3422 = DIRECTION('',(1.221646432603E-27,-8.54607999747E-17,-1.)); +#3423 = DIRECTION('',(-0.707106781188,-0.707106781186,6.042991118679E-17 + )); +#3424 = DEFINITIONAL_REPRESENTATION('',(#3425),#3429); +#3425 = LINE('',#3426,#3427); +#3426 = CARTESIAN_POINT('',(12.566370614359,23.82500000024)); +#3427 = VECTOR('',#3428,1.); +#3428 = DIRECTION('',(-1.,-2.623604217243E-12)); +#3429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3430 = ORIENTED_EDGE('',*,*,#3431,.T.); +#3431 = EDGE_CURVE('',#3403,#3432,#3434,.T.); +#3432 = VERTEX_POINT('',#3433); +#3433 = CARTESIAN_POINT('',(-33.00000000006,-41.59999999999, + 4.499999999844)); +#3434 = SURFACE_CURVE('',#3435,(#3439,#3446),.PCURVE_S1.); +#3435 = LINE('',#3436,#3437); +#3436 = CARTESIAN_POINT('',(-33.00000000009,-64.60000000002, + 4.499999999844)); +#3437 = VECTOR('',#3438,1.); +#3438 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#3439 = PCURVE('',#2628,#3440); +#3440 = DEFINITIONAL_REPRESENTATION('',(#3441),#3445); +#3441 = LINE('',#3442,#3443); +#3442 = CARTESIAN_POINT('',(52.55,-7.83658119035E-14)); +#3443 = VECTOR('',#3444,1.); +#3444 = DIRECTION('',(2.286638207878E-16,1.)); +#3445 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3446 = PCURVE('',#3447,#3452); +#3447 = PLANE('',#3448); +#3448 = AXIS2_PLACEMENT_3D('',#3449,#3450,#3451); +#3449 = CARTESIAN_POINT('',(-33.00000000009,-64.60000000002,38.5)); +#3450 = DIRECTION('',(1.,-1.439293502184E-12,1.344649606698E-27)); +#3451 = DIRECTION('',(8.456613066457E-28,-3.466897469453E-16,-1.)); +#3452 = DEFINITIONAL_REPRESENTATION('',(#3453),#3457); +#3453 = LINE('',#3454,#3455); +#3454 = CARTESIAN_POINT('',(34.000000000156,-2.423403319007E-15)); +#3455 = VECTOR('',#3456,1.); +#3456 = DIRECTION('',(1.486465700216E-15,1.)); +#3457 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3458 = ORIENTED_EDGE('',*,*,#3459,.F.); +#3459 = EDGE_CURVE('',#3460,#3432,#3462,.T.); +#3460 = VERTEX_POINT('',#3461); +#3461 = CARTESIAN_POINT('',(-30.00000000006,-38.59999999999,4.5)); +#3462 = SURFACE_CURVE('',#3463,(#3468,#3475),.PCURVE_S1.); +#3463 = CIRCLE('',#3464,3.); +#3464 = AXIS2_PLACEMENT_3D('',#3465,#3466,#3467); +#3465 = CARTESIAN_POINT('',(-30.00000000006,-41.59999999999, + 4.499999999772)); +#3466 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3467 = DIRECTION('',(-0.707106781186,0.707106781187,-9.726601044281E-13 + )); +#3468 = PCURVE('',#2628,#3469); +#3469 = DEFINITIONAL_REPRESENTATION('',(#3470),#3474); +#3470 = CIRCLE('',#3471,3.); +#3471 = AXIS2_PLACEMENT_2D('',#3472,#3473); +#3472 = CARTESIAN_POINT('',(55.549999999999,23.000000000029)); +#3473 = DIRECTION('',(-0.707106781187,0.707106781186)); +#3474 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3475 = PCURVE('',#3476,#3481); +#3476 = CYLINDRICAL_SURFACE('',#3477,3.); +#3477 = AXIS2_PLACEMENT_3D('',#3478,#3479,#3480); +#3478 = CARTESIAN_POINT('',(-30.00000000006,-41.59999999999,21.5)); +#3479 = DIRECTION('',(-1.16838698865E-27,1.224646799147E-16,1.)); +#3480 = DIRECTION('',(-0.707106781186,0.707106781187,-8.659560562444E-17 + )); +#3481 = DEFINITIONAL_REPRESENTATION('',(#3482),#3486); +#3482 = LINE('',#3483,#3484); +#3483 = CARTESIAN_POINT('',(-1.7763568394E-15,-17.00000000021)); +#3484 = VECTOR('',#3485,1.); +#3485 = DIRECTION('',(1.,-2.623604217245E-12)); +#3486 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3487 = ORIENTED_EDGE('',*,*,#3488,.F.); +#3488 = EDGE_CURVE('',#3489,#3460,#3491,.T.); +#3489 = VERTEX_POINT('',#3490); +#3490 = CARTESIAN_POINT('',(-23.99999999994,-38.59999999999,4.5)); +#3491 = SURFACE_CURVE('',#3492,(#3496,#3503),.PCURVE_S1.); +#3492 = LINE('',#3493,#3494); +#3493 = CARTESIAN_POINT('',(-22.99999999994,-38.59999999999,4.5)); +#3494 = VECTOR('',#3495,1.); +#3495 = DIRECTION('',(-1.,-9.325873406851E-15,6.730674985308E-29)); +#3496 = PCURVE('',#2628,#3497); +#3497 = DEFINITIONAL_REPRESENTATION('',(#3498),#3502); +#3498 = LINE('',#3499,#3500); +#3499 = CARTESIAN_POINT('',(62.55000000011,26.000000000039)); +#3500 = VECTOR('',#3501,1.); +#3501 = DIRECTION('',(-1.,-1.44839071177E-12)); +#3502 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3503 = PCURVE('',#3504,#3509); +#3504 = PLANE('',#3505); +#3505 = AXIS2_PLACEMENT_3D('',#3506,#3507,#3508); +#3506 = CARTESIAN_POINT('',(-22.99999999994,-38.59999999999,4.5)); +#3507 = DIRECTION('',(-9.325873406851E-15,1.,-1.224646799147E-16)); +#3508 = DIRECTION('',(-1.,-9.325873406851E-15,6.730674985308E-29)); +#3509 = DEFINITIONAL_REPRESENTATION('',(#3510),#3514); +#3510 = LINE('',#3511,#3512); +#3511 = CARTESIAN_POINT('',(0.,0.)); +#3512 = VECTOR('',#3513,1.); +#3513 = DIRECTION('',(1.,0.)); +#3514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3515 = ORIENTED_EDGE('',*,*,#3516,.F.); +#3516 = EDGE_CURVE('',#3517,#3489,#3519,.T.); +#3517 = VERTEX_POINT('',#3518); +#3518 = CARTESIAN_POINT('',(-22.99999999994,-37.59999999999,4.5)); +#3519 = SURFACE_CURVE('',#3520,(#3525,#3536),.PCURVE_S1.); +#3520 = CIRCLE('',#3521,1.); +#3521 = AXIS2_PLACEMENT_3D('',#3522,#3523,#3524); +#3522 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999, + 4.499999999772)); +#3523 = DIRECTION('',(1.373715955813E-12,-1.833155449138E-15,-1.)); +#3524 = DIRECTION('',(0.707106781187,-0.707106781187,9.726601044288E-13) + ); +#3525 = PCURVE('',#2628,#3526); +#3526 = DEFINITIONAL_REPRESENTATION('',(#3527),#3535); +#3527 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#3528,#3529,#3530,#3531, +#3532,#3533,#3534),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#3528 = CARTESIAN_POINT('',(62.257106781296,26.292893218852)); +#3529 = CARTESIAN_POINT('',(61.032361909906,25.068148347459)); +#3530 = CARTESIAN_POINT('',(60.58407417382,26.741180954934)); +#3531 = CARTESIAN_POINT('',(60.135786437734,28.414213562409)); +#3532 = CARTESIAN_POINT('',(61.80881904521,27.965925826327)); +#3533 = CARTESIAN_POINT('',(63.481851652686,27.517638090246)); +#3534 = CARTESIAN_POINT('',(62.257106781296,26.292893218852)); +#3535 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3536 = PCURVE('',#3537,#3542); +#3537 = CYLINDRICAL_SURFACE('',#3538,1.); +#3538 = AXIS2_PLACEMENT_3D('',#3539,#3540,#3541); +#3539 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999,4.5)); +#3540 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#3541 = DIRECTION('',(0.707106781187,-0.707106781187,8.65956056235E-17) + ); +#3542 = DEFINITIONAL_REPRESENTATION('',(#3543),#3547); +#3543 = LINE('',#3544,#3545); +#3544 = CARTESIAN_POINT('',(12.566370614359,-2.216964389845E-10)); +#3545 = VECTOR('',#3546,1.); +#3546 = DIRECTION('',(-1.,-8.775503761122E-13)); +#3547 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3548 = ORIENTED_EDGE('',*,*,#3549,.F.); +#3549 = EDGE_CURVE('',#3550,#3517,#3552,.T.); +#3550 = VERTEX_POINT('',#3551); +#3551 = CARTESIAN_POINT('',(-22.99999999994,-36.6,4.5)); +#3552 = SURFACE_CURVE('',#3553,(#3557,#3564),.PCURVE_S1.); +#3553 = LINE('',#3554,#3555); +#3554 = CARTESIAN_POINT('',(-22.99999999994,-35.59999999999,4.5)); +#3555 = VECTOR('',#3556,1.); +#3556 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#3557 = PCURVE('',#2628,#3558); +#3558 = DEFINITIONAL_REPRESENTATION('',(#3559),#3563); +#3559 = LINE('',#3560,#3561); +#3560 = CARTESIAN_POINT('',(62.550000000106,29.000000000039)); +#3561 = VECTOR('',#3562,1.); +#3562 = DIRECTION('',(1.439064838363E-12,-1.)); +#3563 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3564 = PCURVE('',#3101,#3565); +#3565 = DEFINITIONAL_REPRESENTATION('',(#3566),#3570); +#3566 = LINE('',#3567,#3568); +#3567 = CARTESIAN_POINT('',(74.199999999995,-9.086879249673E-15)); +#3568 = VECTOR('',#3569,1.); +#3569 = DIRECTION('',(1.,0.)); +#3570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3571 = ORIENTED_EDGE('',*,*,#3572,.F.); +#3572 = EDGE_CURVE('',#3573,#3550,#3575,.T.); +#3573 = VERTEX_POINT('',#3574); +#3574 = CARTESIAN_POINT('',(-23.99999999995,-35.6,4.5)); +#3575 = SURFACE_CURVE('',#3576,(#3581,#3592),.PCURVE_S1.); +#3576 = CIRCLE('',#3577,1.); +#3577 = AXIS2_PLACEMENT_3D('',#3578,#3579,#3580); +#3578 = CARTESIAN_POINT('',(-23.99999999994,-36.6,4.499999999772)); +#3579 = DIRECTION('',(1.373715955813E-12,-1.833155449138E-15,-1.)); +#3580 = DIRECTION('',(0.707106781186,0.707106781187,9.700676311303E-13) + ); +#3581 = PCURVE('',#2628,#3582); +#3582 = DEFINITIONAL_REPRESENTATION('',(#3583),#3591); +#3583 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#3584,#3585,#3586,#3587, +#3588,#3589,#3590),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#3584 = CARTESIAN_POINT('',(62.257106781293,28.707106781225)); +#3585 = CARTESIAN_POINT('',(63.481851652686,27.482361909836)); +#3586 = CARTESIAN_POINT('',(61.808819045212,27.034074173748)); +#3587 = CARTESIAN_POINT('',(60.135786437737,26.585786437661)); +#3588 = CARTESIAN_POINT('',(60.584074173818,28.258819045138)); +#3589 = CARTESIAN_POINT('',(61.032361909899,29.931851652614)); +#3590 = CARTESIAN_POINT('',(62.257106781293,28.707106781225)); +#3591 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3592 = PCURVE('',#3593,#3598); +#3593 = CYLINDRICAL_SURFACE('',#3594,1.); +#3594 = AXIS2_PLACEMENT_3D('',#3595,#3596,#3597); +#3595 = CARTESIAN_POINT('',(-23.99999999994,-36.6,13.)); +#3596 = DIRECTION('',(-6.616465975138E-29,-1.112809542387E-15,-1.)); +#3597 = DIRECTION('',(0.707106781186,0.707106781187,-7.868751735912E-16) + ); +#3598 = DEFINITIONAL_REPRESENTATION('',(#3599),#3603); +#3599 = LINE('',#3600,#3601); +#3600 = CARTESIAN_POINT('',(-6.28318530718,8.500000000233)); +#3601 = VECTOR('',#3602,1.); +#3602 = DIRECTION('',(1.,-8.685034650179E-13)); +#3603 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3604 = ORIENTED_EDGE('',*,*,#3605,.F.); +#3605 = EDGE_CURVE('',#3606,#3573,#3608,.T.); +#3606 = VERTEX_POINT('',#3607); +#3607 = CARTESIAN_POINT('',(-75.29999999997,-35.60000000004,4.5)); +#3608 = SURFACE_CURVE('',#3609,(#3613,#3620),.PCURVE_S1.); +#3609 = LINE('',#3610,#3611); +#3610 = CARTESIAN_POINT('',(-22.99999999994,-35.59999999999,4.5)); +#3611 = VECTOR('',#3612,1.); +#3612 = DIRECTION('',(1.,7.938040362974E-13,-1.633776169716E-28)); +#3613 = PCURVE('',#2628,#3614); +#3614 = DEFINITIONAL_REPRESENTATION('',(#3615),#3619); +#3615 = LINE('',#3616,#3617); +#3616 = CARTESIAN_POINT('',(62.550000000106,29.000000000039)); +#3617 = VECTOR('',#3618,1.); +#3618 = DIRECTION('',(1.,2.23286887466E-12)); +#3619 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3620 = PCURVE('',#3621,#3626); +#3621 = PLANE('',#3622); +#3622 = AXIS2_PLACEMENT_3D('',#3623,#3624,#3625); +#3623 = CARTESIAN_POINT('',(-49.14999999996,-35.60000000002,21.5)); +#3624 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#3625 = DIRECTION('',(1.,7.938040362974E-13,-1.633776169716E-28)); +#3626 = DEFINITIONAL_REPRESENTATION('',(#3627),#3631); +#3627 = LINE('',#3628,#3629); +#3628 = CARTESIAN_POINT('',(26.150000000012,-17.)); +#3629 = VECTOR('',#3630,1.); +#3630 = DIRECTION('',(1.,2.24207754292E-43)); +#3631 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3632 = ORIENTED_EDGE('',*,*,#3633,.F.); +#3633 = EDGE_CURVE('',#3634,#3606,#3636,.T.); +#3634 = VERTEX_POINT('',#3635); +#3635 = CARTESIAN_POINT('',(-75.30000000002,-30.59999999999,4.5)); +#3636 = SURFACE_CURVE('',#3637,(#3641,#3648),.PCURVE_S1.); +#3637 = LINE('',#3638,#3639); +#3638 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,4.5)); +#3639 = VECTOR('',#3640,1.); +#3640 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#3641 = PCURVE('',#2628,#3642); +#3642 = DEFINITIONAL_REPRESENTATION('',(#3643),#3647); +#3643 = LINE('',#3644,#3645); +#3644 = CARTESIAN_POINT('',(10.250000000071,34.299999999923)); +#3645 = VECTOR('',#3646,1.); +#3646 = DIRECTION('',(2.232560086906E-12,-1.)); +#3647 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3648 = PCURVE('',#3649,#3654); +#3649 = PLANE('',#3650); +#3650 = AXIS2_PLACEMENT_3D('',#3651,#3652,#3653); +#3651 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,38.5)); +#3652 = DIRECTION('',(-1.,-7.934952485434E-13,1.630339950124E-28)); +#3653 = DIRECTION('',(7.199750894054E-28,-1.112809542387E-15,-1.)); +#3654 = DEFINITIONAL_REPRESENTATION('',(#3655),#3659); +#3655 = LINE('',#3656,#3657); +#3656 = CARTESIAN_POINT('',(34.,-3.073009708355E-14)); +#3657 = VECTOR('',#3658,1.); +#3658 = DIRECTION('',(-6.854634765848E-16,1.)); +#3659 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3660 = ORIENTED_EDGE('',*,*,#3661,.T.); +#3661 = EDGE_CURVE('',#3634,#3662,#3664,.T.); +#3662 = VERTEX_POINT('',#3663); +#3663 = CARTESIAN_POINT('',(-24.99999999994,-30.59999999999,4.5)); +#3664 = SURFACE_CURVE('',#3665,(#3669,#3676),.PCURVE_S1.); +#3665 = LINE('',#3666,#3667); +#3666 = CARTESIAN_POINT('',(-12.49999999997,-30.59999999999,4.5)); +#3667 = VECTOR('',#3668,1.); +#3668 = DIRECTION('',(1.,-8.10283387812E-45,-6.616465975138E-29)); +#3669 = PCURVE('',#2628,#3670); +#3670 = DEFINITIONAL_REPRESENTATION('',(#3671),#3675); +#3671 = LINE('',#3672,#3673); +#3672 = CARTESIAN_POINT('',(73.050000000078,34.000000000054)); +#3673 = VECTOR('',#3674,1.); +#3674 = DIRECTION('',(1.,1.439064838363E-12)); +#3675 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3676 = PCURVE('',#3677,#3682); +#3677 = PLANE('',#3678); +#3678 = AXIS2_PLACEMENT_3D('',#3679,#3680,#3681); +#3679 = CARTESIAN_POINT('',(-75.30000000002,-30.59999999999,4.5)); +#3680 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#3681 = DIRECTION('',(1.,-8.10283387812E-45,-6.616465975138E-29)); +#3682 = DEFINITIONAL_REPRESENTATION('',(#3683),#3687); +#3683 = LINE('',#3684,#3685); +#3684 = CARTESIAN_POINT('',(62.800000000059,8.310281264781E-27)); +#3685 = VECTOR('',#3686,1.); +#3686 = DIRECTION('',(1.,0.)); +#3687 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3688 = ORIENTED_EDGE('',*,*,#3689,.F.); +#3689 = EDGE_CURVE('',#3690,#3662,#3692,.T.); +#3690 = VERTEX_POINT('',#3691); +#3691 = CARTESIAN_POINT('',(-20.99999999994,-34.59999999999,4.5)); +#3692 = SURFACE_CURVE('',#3693,(#3698,#3705),.PCURVE_S1.); +#3693 = CIRCLE('',#3694,4.); +#3694 = AXIS2_PLACEMENT_3D('',#3695,#3696,#3697); +#3695 = CARTESIAN_POINT('',(-24.99999999994,-34.59999999999, + 4.499999999772)); +#3696 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3697 = DIRECTION('',(0.707106781187,0.707106781187,9.700676311307E-13) + ); +#3698 = PCURVE('',#2628,#3699); +#3699 = DEFINITIONAL_REPRESENTATION('',(#3700),#3704); +#3700 = CIRCLE('',#3701,4.); +#3701 = AXIS2_PLACEMENT_2D('',#3702,#3703); +#3702 = CARTESIAN_POINT('',(60.550000000104,30.000000000036)); +#3703 = DIRECTION('',(0.707106781186,0.707106781188)); +#3704 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3705 = PCURVE('',#3706,#3711); +#3706 = CYLINDRICAL_SURFACE('',#3707,4.); +#3707 = AXIS2_PLACEMENT_3D('',#3708,#3709,#3710); +#3708 = CARTESIAN_POINT('',(-24.99999999994,-34.59999999999,4.5)); +#3709 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#3710 = DIRECTION('',(0.707106781187,0.707106781187,-8.65956056236E-17) + ); +#3711 = DEFINITIONAL_REPRESENTATION('',(#3712),#3716); +#3712 = LINE('',#3713,#3714); +#3713 = CARTESIAN_POINT('',(0.,-2.031512735812E-10)); +#3714 = VECTOR('',#3715,1.); +#3715 = DIRECTION('',(1.,-3.501154593355E-12)); +#3716 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3717 = ORIENTED_EDGE('',*,*,#3718,.T.); +#3718 = EDGE_CURVE('',#3690,#3719,#3721,.T.); +#3719 = VERTEX_POINT('',#3720); +#3720 = CARTESIAN_POINT('',(-20.99999999994,-37.59999999999,4.5)); +#3721 = SURFACE_CURVE('',#3722,(#3726,#3733),.PCURVE_S1.); +#3722 = LINE('',#3723,#3724); +#3723 = CARTESIAN_POINT('',(-20.99999999994,19.299999999997,4.5)); +#3724 = VECTOR('',#3725,1.); +#3725 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#3726 = PCURVE('',#2628,#3727); +#3727 = DEFINITIONAL_REPRESENTATION('',(#3728),#3732); +#3728 = LINE('',#3729,#3730); +#3729 = CARTESIAN_POINT('',(64.550000000027,83.900000000038)); +#3730 = VECTOR('',#3731,1.); +#3731 = DIRECTION('',(1.439064838363E-12,-1.)); +#3732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3733 = PCURVE('',#2927,#3734); +#3734 = DEFINITIONAL_REPRESENTATION('',(#3735),#3739); +#3735 = LINE('',#3736,#3737); +#3736 = CARTESIAN_POINT('',(19.299999999999,-2.363568322354E-15)); +#3737 = VECTOR('',#3738,1.); +#3738 = DIRECTION('',(1.,0.)); +#3739 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3740 = ORIENTED_EDGE('',*,*,#3741,.F.); +#3741 = EDGE_CURVE('',#3742,#3719,#3744,.T.); +#3742 = VERTEX_POINT('',#3743); +#3743 = CARTESIAN_POINT('',(-23.99999999994,-40.59999999999,4.5)); +#3744 = SURFACE_CURVE('',#3745,(#3750,#3757),.PCURVE_S1.); +#3745 = CIRCLE('',#3746,3.); +#3746 = AXIS2_PLACEMENT_3D('',#3747,#3748,#3749); +#3747 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999, + 4.499999999772)); +#3748 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#3749 = DIRECTION('',(0.707106781187,-0.707106781187,9.726601044288E-13) + ); +#3750 = PCURVE('',#2628,#3751); +#3751 = DEFINITIONAL_REPRESENTATION('',(#3752),#3756); +#3752 = CIRCLE('',#3753,3.); +#3753 = AXIS2_PLACEMENT_2D('',#3754,#3755); +#3754 = CARTESIAN_POINT('',(61.550000000109,27.000000000038)); +#3755 = DIRECTION('',(0.707106781188,-0.707106781186)); +#3756 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3757 = PCURVE('',#3758,#3763); +#3758 = CYLINDRICAL_SURFACE('',#3759,3.); +#3759 = AXIS2_PLACEMENT_3D('',#3760,#3761,#3762); +#3760 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999,4.5)); +#3761 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#3762 = DIRECTION('',(0.707106781187,-0.707106781187,8.65956056235E-17) + ); +#3763 = DEFINITIONAL_REPRESENTATION('',(#3764),#3768); +#3764 = LINE('',#3765,#3766); +#3765 = CARTESIAN_POINT('',(-1.7763568394E-15,-2.423234946036E-10)); +#3766 = VECTOR('',#3767,1.); +#3767 = DIRECTION('',(1.,2.623604217243E-12)); +#3768 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3769 = ORIENTED_EDGE('',*,*,#3770,.T.); +#3770 = EDGE_CURVE('',#3742,#3771,#3773,.T.); +#3771 = VERTEX_POINT('',#3772); +#3772 = CARTESIAN_POINT('',(-25.49999999994,-40.59999999999,4.5)); +#3773 = SURFACE_CURVE('',#3774,(#3778,#3785),.PCURVE_S1.); +#3774 = LINE('',#3775,#3776); +#3775 = CARTESIAN_POINT('',(-12.49999999996,-40.59999999999,4.5)); +#3776 = VECTOR('',#3777,1.); +#3777 = DIRECTION('',(-1.,-9.325873406851E-15,6.730674985308E-29)); +#3778 = PCURVE('',#2628,#3779); +#3779 = DEFINITIONAL_REPRESENTATION('',(#3780),#3784); +#3780 = LINE('',#3781,#3782); +#3781 = CARTESIAN_POINT('',(73.050000000092,24.000000000055)); +#3782 = VECTOR('',#3783,1.); +#3783 = DIRECTION('',(-1.,-1.44839071177E-12)); +#3784 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3785 = PCURVE('',#3786,#3791); +#3786 = PLANE('',#3787); +#3787 = AXIS2_PLACEMENT_3D('',#3788,#3789,#3790); +#3788 = CARTESIAN_POINT('',(-22.99999999994,-40.59999999999,4.5)); +#3789 = DIRECTION('',(-9.325873406851E-15,1.,-1.224646799147E-16)); +#3790 = DIRECTION('',(-1.,-9.325873406851E-15,6.730674985308E-29)); +#3791 = DEFINITIONAL_REPRESENTATION('',(#3792),#3796); +#3792 = LINE('',#3793,#3794); +#3793 = CARTESIAN_POINT('',(-10.49999999997,1.401640149194E-27)); +#3794 = VECTOR('',#3795,1.); +#3795 = DIRECTION('',(1.,0.)); +#3796 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3797 = ORIENTED_EDGE('',*,*,#3798,.F.); +#3798 = EDGE_CURVE('',#3799,#3771,#3801,.T.); +#3799 = VERTEX_POINT('',#3800); +#3800 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,4.5)); +#3801 = SURFACE_CURVE('',#3802,(#3806,#3813),.PCURVE_S1.); +#3802 = LINE('',#3803,#3804); +#3803 = CARTESIAN_POINT('',(-25.49999999994,-19.3,4.5)); +#3804 = VECTOR('',#3805,1.); +#3805 = DIRECTION('',(-6.704039033313E-15,1.,-1.224646799147E-16)); +#3806 = PCURVE('',#2628,#3807); +#3807 = DEFINITIONAL_REPRESENTATION('',(#3808),#3812); +#3808 = LINE('',#3809,#3810); +#3809 = CARTESIAN_POINT('',(60.050000000082,45.300000000034)); +#3810 = VECTOR('',#3811,1.); +#3811 = DIRECTION('',(-1.445768877396E-12,1.)); +#3812 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3813 = PCURVE('',#3814,#3819); +#3814 = PLANE('',#3815); +#3815 = AXIS2_PLACEMENT_3D('',#3816,#3817,#3818); +#3816 = CARTESIAN_POINT('',(-25.49999999994,-38.59999999999,4.5)); +#3817 = DIRECTION('',(1.,6.459479416001E-15,-6.695571783048E-29)); +#3818 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#3819 = DEFINITIONAL_REPRESENTATION('',(#3820),#3824); +#3820 = LINE('',#3821,#3822); +#3821 = CARTESIAN_POINT('',(-2.363568322354E-15,19.299999999999)); +#3822 = VECTOR('',#3823,1.); +#3823 = DIRECTION('',(0.,1.)); +#3824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3825 = ORIENTED_EDGE('',*,*,#3826,.T.); +#3826 = EDGE_CURVE('',#3799,#3827,#3829,.T.); +#3827 = VERTEX_POINT('',#3828); +#3828 = CARTESIAN_POINT('',(22.000000000023,-62.59999999999,4.5)); +#3829 = SURFACE_CURVE('',#3830,(#3834,#3841),.PCURVE_S1.); +#3830 = LINE('',#3831,#3832); +#3831 = CARTESIAN_POINT('',(64.449999999906,-62.60000000016, + 4.499999999978)); +#3832 = VECTOR('',#3833,1.); +#3833 = DIRECTION('',(1.,-1.439064838363E-12,1.373715955813E-12)); +#3834 = PCURVE('',#2628,#3835); +#3835 = DEFINITIONAL_REPRESENTATION('',(#3836),#3840); +#3836 = LINE('',#3837,#3838); +#3837 = CARTESIAN_POINT('',(149.99999999999,2.)); +#3838 = VECTOR('',#3839,1.); +#3839 = DIRECTION('',(1.,1.070942053239E-28)); +#3840 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3841 = PCURVE('',#3842,#3847); +#3842 = PLANE('',#3843); +#3843 = AXIS2_PLACEMENT_3D('',#3844,#3845,#3846); +#3844 = CARTESIAN_POINT('',(-22.7000000001,-62.60000000003, + 18.149999999987)); +#3845 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#3846 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#3847 = DEFINITIONAL_REPRESENTATION('',(#3848),#3852); +#3848 = LINE('',#3849,#3850); +#3849 = CARTESIAN_POINT('',(13.650000000009,87.15000000001)); +#3850 = VECTOR('',#3851,1.); +#3851 = DIRECTION('',(-1.373715955813E-12,1.)); +#3852 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3853 = ORIENTED_EDGE('',*,*,#3854,.F.); +#3854 = EDGE_CURVE('',#3855,#3827,#3857,.T.); +#3855 = VERTEX_POINT('',#3856); +#3856 = CARTESIAN_POINT('',(22.000000000023,-52.59999999999,4.5)); +#3857 = SURFACE_CURVE('',#3858,(#3862,#3869),.PCURVE_S1.); +#3858 = LINE('',#3859,#3860); +#3859 = CARTESIAN_POINT('',(22.000000000023,-52.59999999999,4.5)); +#3860 = VECTOR('',#3861,1.); +#3861 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#3862 = PCURVE('',#2628,#3863); +#3863 = DEFINITIONAL_REPRESENTATION('',(#3864),#3868); +#3864 = LINE('',#3865,#3866); +#3865 = CARTESIAN_POINT('',(107.5500000001,12.000000000104)); +#3866 = VECTOR('',#3867,1.); +#3867 = DIRECTION('',(1.441508245295E-12,-1.)); +#3868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3869 = PCURVE('',#3870,#3875); +#3870 = PLANE('',#3871); +#3871 = AXIS2_PLACEMENT_3D('',#3872,#3873,#3874); +#3872 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#3873 = DIRECTION('',(1.,-1.439293502184E-12,1.344589873089E-27)); +#3874 = DIRECTION('',(1.221586698994E-27,-8.54607999747E-17,-1.)); +#3875 = DEFINITIONAL_REPRESENTATION('',(#3876),#3880); +#3876 = LINE('',#3877,#3878); +#3877 = CARTESIAN_POINT('',(27.,12.000000000104)); +#3878 = VECTOR('',#3879,1.); +#3879 = DIRECTION('',(-3.700387994003E-17,-1.)); +#3880 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3881 = ORIENTED_EDGE('',*,*,#3882,.F.); +#3882 = EDGE_CURVE('',#3883,#3855,#3885,.T.); +#3883 = VERTEX_POINT('',#3884); +#3884 = CARTESIAN_POINT('',(27.000000000023,-52.59999999999,4.5)); +#3885 = SURFACE_CURVE('',#3886,(#3890,#3897),.PCURVE_S1.); +#3886 = LINE('',#3887,#3888); +#3887 = CARTESIAN_POINT('',(27.000000000023,-52.59999999999,4.5)); +#3888 = VECTOR('',#3889,1.); +#3889 = DIRECTION('',(-1.,-1.7763568394E-15,6.638220072313E-29)); +#3890 = PCURVE('',#2628,#3891); +#3891 = DEFINITIONAL_REPRESENTATION('',(#3892),#3896); +#3892 = LINE('',#3893,#3894); +#3893 = CARTESIAN_POINT('',(112.5500000001,12.000000000111)); +#3894 = VECTOR('',#3895,1.); +#3895 = DIRECTION('',(-1.,-1.440841195202E-12)); +#3896 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3897 = PCURVE('',#3898,#3903); +#3898 = PLANE('',#3899); +#3899 = AXIS2_PLACEMENT_3D('',#3900,#3901,#3902); +#3900 = CARTESIAN_POINT('',(27.000000000023,-52.59999999999,36.5)); +#3901 = DIRECTION('',(-1.7763568394E-15,1.,-1.224646799147E-16)); +#3902 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#3903 = DEFINITIONAL_REPRESENTATION('',(#3904),#3908); +#3904 = LINE('',#3905,#3906); +#3905 = CARTESIAN_POINT('',(32.,-4.365528295599E-27)); +#3906 = VECTOR('',#3907,1.); +#3907 = DIRECTION('',(4.270329215564E-30,1.)); +#3908 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3909 = ORIENTED_EDGE('',*,*,#3910,.T.); +#3910 = EDGE_CURVE('',#3883,#3911,#3913,.T.); +#3911 = VERTEX_POINT('',#3912); +#3912 = CARTESIAN_POINT('',(27.000000000023,-2.599999999999,4.5)); +#3913 = SURFACE_CURVE('',#3914,(#3918,#3925),.PCURVE_S1.); +#3914 = LINE('',#3915,#3916); +#3915 = CARTESIAN_POINT('',(27.000000000023,-32.3,4.5)); +#3916 = VECTOR('',#3917,1.); +#3917 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#3918 = PCURVE('',#2628,#3919); +#3919 = DEFINITIONAL_REPRESENTATION('',(#3920),#3924); +#3920 = LINE('',#3921,#3922); +#3921 = CARTESIAN_POINT('',(112.55000000007,32.30000000011)); +#3922 = VECTOR('',#3923,1.); +#3923 = DIRECTION('',(-1.441539638913E-12,1.)); +#3924 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3925 = PCURVE('',#3926,#3931); +#3926 = PLANE('',#3927); +#3927 = AXIS2_PLACEMENT_3D('',#3928,#3929,#3930); +#3928 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#3929 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#3930 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#3931 = DEFINITIONAL_REPRESENTATION('',(#3932),#3936); +#3932 = LINE('',#3933,#3934); +#3933 = CARTESIAN_POINT('',(32.299999999999,-1.025524555396E-14)); +#3934 = VECTOR('',#3935,1.); +#3935 = DIRECTION('',(1.,0.)); +#3936 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3937 = ORIENTED_EDGE('',*,*,#3938,.T.); +#3938 = EDGE_CURVE('',#3911,#3939,#3941,.T.); +#3939 = VERTEX_POINT('',#3940); +#3940 = CARTESIAN_POINT('',(22.000000000023,-2.599999999999,4.5)); +#3941 = SURFACE_CURVE('',#3942,(#3946,#3953),.PCURVE_S1.); +#3942 = LINE('',#3943,#3944); +#3943 = CARTESIAN_POINT('',(27.000000000023,-2.599999999999,4.5)); +#3944 = VECTOR('',#3945,1.); +#3945 = DIRECTION('',(-1.,-2.442490654175E-15,6.646377858754E-29)); +#3946 = PCURVE('',#2628,#3947); +#3947 = DEFINITIONAL_REPRESENTATION('',(#3948),#3952); +#3948 = LINE('',#3949,#3950); +#3949 = CARTESIAN_POINT('',(112.55000000003,62.000000000111)); +#3950 = VECTOR('',#3951,1.); +#3951 = DIRECTION('',(-1.,-1.441507329017E-12)); +#3952 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3953 = PCURVE('',#3954,#3959); +#3954 = PLANE('',#3955); +#3955 = AXIS2_PLACEMENT_3D('',#3956,#3957,#3958); +#3956 = CARTESIAN_POINT('',(27.000000000023,-2.599999999999,4.5)); +#3957 = DIRECTION('',(2.442490654175E-15,-1.,5.307574087566E-17)); +#3958 = DIRECTION('',(7.060453438158E-29,5.307574087566E-17,1.)); +#3959 = DEFINITIONAL_REPRESENTATION('',(#3960),#3964); +#3960 = LINE('',#3961,#3962); +#3961 = CARTESIAN_POINT('',(0.,0.)); +#3962 = VECTOR('',#3963,1.); +#3963 = DIRECTION('',(-4.270392795095E-30,1.)); +#3964 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3965 = ORIENTED_EDGE('',*,*,#3966,.F.); +#3966 = EDGE_CURVE('',#3967,#3939,#3969,.T.); +#3967 = VERTEX_POINT('',#3968); +#3968 = CARTESIAN_POINT('',(22.000000000023,3.400000000001,4.5)); +#3969 = SURFACE_CURVE('',#3970,(#3974,#3981),.PCURVE_S1.); +#3970 = LINE('',#3971,#3972); +#3971 = CARTESIAN_POINT('',(22.000000000023,3.400000000001,4.5)); +#3972 = VECTOR('',#3973,1.); +#3973 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#3974 = PCURVE('',#2628,#3975); +#3975 = DEFINITIONAL_REPRESENTATION('',(#3976),#3980); +#3976 = LINE('',#3977,#3978); +#3977 = CARTESIAN_POINT('',(107.55000000002,68.000000000104)); +#3978 = VECTOR('',#3979,1.); +#3979 = DIRECTION('',(1.441508245295E-12,-1.)); +#3980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3981 = PCURVE('',#3982,#3987); +#3982 = PLANE('',#3983); +#3983 = AXIS2_PLACEMENT_3D('',#3984,#3985,#3986); +#3984 = CARTESIAN_POINT('',(22.000000000023,0.400000000001,20.5)); +#3985 = DIRECTION('',(-1.,-2.443406931777E-15,7.073422001475E-29)); +#3986 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#3987 = DEFINITIONAL_REPRESENTATION('',(#3988),#3992); +#3988 = LINE('',#3989,#3990); +#3989 = CARTESIAN_POINT('',(-3.,-16.)); +#3990 = VECTOR('',#3991,1.); +#3991 = DIRECTION('',(1.,0.)); +#3992 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#3993 = ORIENTED_EDGE('',*,*,#3994,.F.); +#3994 = EDGE_CURVE('',#3995,#3967,#3997,.T.); +#3995 = VERTEX_POINT('',#3996); +#3996 = CARTESIAN_POINT('',(27.000000000023,3.400000000001,4.5)); +#3997 = SURFACE_CURVE('',#3998,(#4002,#4009),.PCURVE_S1.); +#3998 = LINE('',#3999,#4000); +#3999 = CARTESIAN_POINT('',(27.000000000023,3.400000000001,4.5)); +#4000 = VECTOR('',#4001,1.); +#4001 = DIRECTION('',(-1.,-2.442490654175E-15,6.646377858754E-29)); +#4002 = PCURVE('',#2628,#4003); +#4003 = DEFINITIONAL_REPRESENTATION('',(#4004),#4008); +#4004 = LINE('',#4005,#4006); +#4005 = CARTESIAN_POINT('',(112.55000000002,68.000000000111)); +#4006 = VECTOR('',#4007,1.); +#4007 = DIRECTION('',(-1.,-1.441507329017E-12)); +#4008 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4009 = PCURVE('',#4010,#4015); +#4010 = PLANE('',#4011); +#4011 = AXIS2_PLACEMENT_3D('',#4012,#4013,#4014); +#4012 = CARTESIAN_POINT('',(27.000000000023,3.400000000001,36.5)); +#4013 = DIRECTION('',(-2.442490654175E-15,1.,-1.224646799147E-16)); +#4014 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#4015 = DEFINITIONAL_REPRESENTATION('',(#4016),#4020); +#4016 = LINE('',#4017,#4018); +#4017 = CARTESIAN_POINT('',(32.,-4.370998408041E-27)); +#4018 = VECTOR('',#4019,1.); +#4019 = DIRECTION('',(4.270329215564E-30,1.)); +#4020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4021 = ORIENTED_EDGE('',*,*,#4022,.T.); +#4022 = EDGE_CURVE('',#3995,#4023,#4025,.T.); +#4023 = VERTEX_POINT('',#4024); +#4024 = CARTESIAN_POINT('',(27.000000000023,13.400000000001,4.5)); +#4025 = SURFACE_CURVE('',#4026,(#4030,#4037),.PCURVE_S1.); +#4026 = LINE('',#4027,#4028); +#4027 = CARTESIAN_POINT('',(27.000000000023,-32.3,4.5)); +#4028 = VECTOR('',#4029,1.); +#4029 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#4030 = PCURVE('',#2628,#4031); +#4031 = DEFINITIONAL_REPRESENTATION('',(#4032),#4036); +#4032 = LINE('',#4033,#4034); +#4033 = CARTESIAN_POINT('',(112.55000000007,32.30000000011)); +#4034 = VECTOR('',#4035,1.); +#4035 = DIRECTION('',(-1.441539638913E-12,1.)); +#4036 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4037 = PCURVE('',#4038,#4043); +#4038 = PLANE('',#4039); +#4039 = AXIS2_PLACEMENT_3D('',#4040,#4041,#4042); +#4040 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#4041 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#4042 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#4043 = DEFINITIONAL_REPRESENTATION('',(#4044),#4048); +#4044 = LINE('',#4045,#4046); +#4045 = CARTESIAN_POINT('',(32.299999999999,-1.025524555396E-14)); +#4046 = VECTOR('',#4047,1.); +#4047 = DIRECTION('',(1.,0.)); +#4048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4049 = ORIENTED_EDGE('',*,*,#4050,.T.); +#4050 = EDGE_CURVE('',#4023,#4051,#4053,.T.); +#4051 = VERTEX_POINT('',#4052); +#4052 = CARTESIAN_POINT('',(22.000000000023,13.400000000001,4.5)); +#4053 = SURFACE_CURVE('',#4054,(#4058,#4065),.PCURVE_S1.); +#4054 = LINE('',#4055,#4056); +#4055 = CARTESIAN_POINT('',(27.000000000023,13.400000000001,4.5)); +#4056 = VECTOR('',#4057,1.); +#4057 = DIRECTION('',(-1.,-2.6645352591E-15,6.649097120901E-29)); +#4058 = PCURVE('',#2628,#4059); +#4059 = DEFINITIONAL_REPRESENTATION('',(#4060),#4064); +#4060 = LINE('',#4061,#4062); +#4061 = CARTESIAN_POINT('',(112.55,78.000000000111)); +#4062 = VECTOR('',#4063,1.); +#4063 = DIRECTION('',(-1.,-1.441729373622E-12)); +#4064 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4065 = PCURVE('',#4066,#4071); +#4066 = PLANE('',#4067); +#4067 = AXIS2_PLACEMENT_3D('',#4068,#4069,#4070); +#4068 = CARTESIAN_POINT('',(27.000000000023,13.400000000001,4.5)); +#4069 = DIRECTION('',(2.6645352591E-15,-1.,1.224646799147E-16)); +#4070 = DIRECTION('',(7.043498896695E-29,1.224646799147E-16,1.)); +#4071 = DEFINITIONAL_REPRESENTATION('',(#4072),#4076); +#4072 = LINE('',#4073,#4074); +#4073 = CARTESIAN_POINT('',(0.,0.)); +#4074 = VECTOR('',#4075,1.); +#4075 = DIRECTION('',(-4.270329215564E-30,1.)); +#4076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4077 = ORIENTED_EDGE('',*,*,#4078,.F.); +#4078 = EDGE_CURVE('',#4079,#4051,#4081,.T.); +#4079 = VERTEX_POINT('',#4080); +#4080 = CARTESIAN_POINT('',(22.000000000023,19.400000000001,4.5)); +#4081 = SURFACE_CURVE('',#4082,(#4086,#4093),.PCURVE_S1.); +#4082 = LINE('',#4083,#4084); +#4083 = CARTESIAN_POINT('',(22.000000000023,19.400000000001,4.5)); +#4084 = VECTOR('',#4085,1.); +#4085 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#4086 = PCURVE('',#2628,#4087); +#4087 = DEFINITIONAL_REPRESENTATION('',(#4088),#4092); +#4088 = LINE('',#4089,#4090); +#4089 = CARTESIAN_POINT('',(107.54999999999,84.000000000104)); +#4090 = VECTOR('',#4091,1.); +#4091 = DIRECTION('',(1.441508245295E-12,-1.)); +#4092 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4093 = PCURVE('',#4094,#4099); +#4094 = PLANE('',#4095); +#4095 = AXIS2_PLACEMENT_3D('',#4096,#4097,#4098); +#4096 = CARTESIAN_POINT('',(22.000000000023,16.400000000001,20.5)); +#4097 = DIRECTION('',(-1.,-2.443406931777E-15,7.073422001475E-29)); +#4098 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#4099 = DEFINITIONAL_REPRESENTATION('',(#4100),#4104); +#4100 = LINE('',#4101,#4102); +#4101 = CARTESIAN_POINT('',(-3.,-16.)); +#4102 = VECTOR('',#4103,1.); +#4103 = DIRECTION('',(1.,0.)); +#4104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4105 = ORIENTED_EDGE('',*,*,#4106,.F.); +#4106 = EDGE_CURVE('',#4107,#4079,#4109,.T.); +#4107 = VERTEX_POINT('',#4108); +#4108 = CARTESIAN_POINT('',(27.000000000023,19.400000000001,4.5)); +#4109 = SURFACE_CURVE('',#4110,(#4114,#4121),.PCURVE_S1.); +#4110 = LINE('',#4111,#4112); +#4111 = CARTESIAN_POINT('',(27.000000000023,19.400000000001,4.5)); +#4112 = VECTOR('',#4113,1.); +#4113 = DIRECTION('',(-1.,-2.6645352591E-15,6.649097120901E-29)); +#4114 = PCURVE('',#2628,#4115); +#4115 = DEFINITIONAL_REPRESENTATION('',(#4116),#4120); +#4116 = LINE('',#4117,#4118); +#4117 = CARTESIAN_POINT('',(112.54999999999,84.000000000111)); +#4118 = VECTOR('',#4119,1.); +#4119 = DIRECTION('',(-1.,-1.441729373622E-12)); +#4120 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4121 = PCURVE('',#4122,#4127); +#4122 = PLANE('',#4123); +#4123 = AXIS2_PLACEMENT_3D('',#4124,#4125,#4126); +#4124 = CARTESIAN_POINT('',(27.000000000023,19.400000000001,36.5)); +#4125 = DIRECTION('',(-2.6645352591E-15,1.,-1.224646799147E-16)); +#4126 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#4127 = DEFINITIONAL_REPRESENTATION('',(#4128),#4132); +#4128 = LINE('',#4129,#4130); +#4129 = CARTESIAN_POINT('',(32.,-4.372164394768E-27)); +#4130 = VECTOR('',#4131,1.); +#4131 = DIRECTION('',(4.270329215564E-30,1.)); +#4132 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4133 = ORIENTED_EDGE('',*,*,#4134,.T.); +#4134 = EDGE_CURVE('',#4107,#4135,#4137,.T.); +#4135 = VERTEX_POINT('',#4136); +#4136 = CARTESIAN_POINT('',(27.000000000023,58.599999999999,4.5)); +#4137 = SURFACE_CURVE('',#4138,(#4142,#4149),.PCURVE_S1.); +#4138 = LINE('',#4139,#4140); +#4139 = CARTESIAN_POINT('',(27.000000000023,-32.3,4.5)); +#4140 = VECTOR('',#4141,1.); +#4141 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#4142 = PCURVE('',#2628,#4143); +#4143 = DEFINITIONAL_REPRESENTATION('',(#4144),#4148); +#4144 = LINE('',#4145,#4146); +#4145 = CARTESIAN_POINT('',(112.55000000007,32.30000000011)); +#4146 = VECTOR('',#4147,1.); +#4147 = DIRECTION('',(-1.441539638913E-12,1.)); +#4148 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4149 = PCURVE('',#4150,#4155); +#4150 = PLANE('',#4151); +#4151 = AXIS2_PLACEMENT_3D('',#4152,#4153,#4154); +#4152 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#4153 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#4154 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#4155 = DEFINITIONAL_REPRESENTATION('',(#4156),#4160); +#4156 = LINE('',#4157,#4158); +#4157 = CARTESIAN_POINT('',(32.299999999999,-1.025524555396E-14)); +#4158 = VECTOR('',#4159,1.); +#4159 = DIRECTION('',(1.,0.)); +#4160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4161 = ORIENTED_EDGE('',*,*,#4162,.T.); +#4162 = EDGE_CURVE('',#4135,#4163,#4165,.T.); +#4163 = VERTEX_POINT('',#4164); +#4164 = CARTESIAN_POINT('',(26.000000000014,58.6,4.499999999925)); +#4165 = SURFACE_CURVE('',#4166,(#4170,#4177),.PCURVE_S1.); +#4166 = LINE('',#4167,#4168); +#4167 = CARTESIAN_POINT('',(24.500000000038,58.600000000003, + 4.499999999923)); +#4168 = VECTOR('',#4169,1.); +#4169 = DIRECTION('',(-1.,1.434852610085E-12,-1.373715955813E-12)); +#4170 = PCURVE('',#2628,#4171); +#4171 = DEFINITIONAL_REPRESENTATION('',(#4172),#4176); +#4172 = LINE('',#4173,#4174); +#4173 = CARTESIAN_POINT('',(110.04999999995,123.2000000001)); +#4174 = VECTOR('',#4175,1.); +#4175 = DIRECTION('',(-1.,-4.21222827771E-15)); +#4176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4177 = PCURVE('',#4178,#4183); +#4178 = PLANE('',#4179); +#4179 = AXIS2_PLACEMENT_3D('',#4180,#4181,#4182); +#4180 = CARTESIAN_POINT('',(23.000000000014,58.600000000005,38.5)); +#4181 = DIRECTION('',(1.434852610085E-12,1.,6.669143989382E-17)); +#4182 = DIRECTION('',(1.,-1.434852610085E-12,-8.411625556336E-29)); +#4183 = DEFINITIONAL_REPRESENTATION('',(#4184),#4188); +#4184 = LINE('',#4185,#4186); +#4185 = CARTESIAN_POINT('',(1.500000000023,34.000000000077)); +#4186 = VECTOR('',#4187,1.); +#4187 = DIRECTION('',(-1.,1.373715955813E-12)); +#4188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4189 = ORIENTED_EDGE('',*,*,#4190,.F.); +#4190 = EDGE_CURVE('',#4191,#4163,#4193,.T.); +#4191 = VERTEX_POINT('',#4192); +#4192 = CARTESIAN_POINT('',(23.000000000019,61.600000000005, + 4.499999999921)); +#4193 = SURFACE_CURVE('',#4194,(#4199,#4206),.PCURVE_S1.); +#4194 = CIRCLE('',#4195,3.); +#4195 = AXIS2_PLACEMENT_3D('',#4196,#4197,#4198); +#4196 = CARTESIAN_POINT('',(26.000000000019,61.6,4.499999999772)); +#4197 = DIRECTION('',(-1.373715955813E-12,1.833155449138E-15,1.)); +#4198 = DIRECTION('',(-0.707106781188,-0.707106781186, + -9.700676311321E-13)); +#4199 = PCURVE('',#2628,#4200); +#4200 = DEFINITIONAL_REPRESENTATION('',(#4201),#4205); +#4201 = CIRCLE('',#4202,3.); +#4202 = AXIS2_PLACEMENT_2D('',#4203,#4204); +#4203 = CARTESIAN_POINT('',(111.54999999993,126.2000000001)); +#4204 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#4205 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4206 = PCURVE('',#4207,#4212); +#4207 = CYLINDRICAL_SURFACE('',#4208,3.); +#4208 = AXIS2_PLACEMENT_3D('',#4209,#4210,#4211); +#4209 = CARTESIAN_POINT('',(26.000000000019,61.6,38.5)); +#4210 = DIRECTION('',(1.432541048686E-27,6.669143989382E-17,-1.)); +#4211 = DIRECTION('',(-0.707106781188,-0.707106781186, + -4.715796939696E-17)); +#4212 = DEFINITIONAL_REPRESENTATION('',(#4213),#4217); +#4213 = LINE('',#4214,#4215); +#4214 = CARTESIAN_POINT('',(6.28318530718,34.000000000246)); +#4215 = VECTOR('',#4216,1.); +#4216 = DIRECTION('',(-1.,-2.623604217243E-12)); +#4217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4218 = ORIENTED_EDGE('',*,*,#4219,.T.); +#4219 = EDGE_CURVE('',#4191,#4220,#4222,.T.); +#4220 = VERTEX_POINT('',#4221); +#4221 = CARTESIAN_POINT('',(23.00000000002,62.599999999996, + 4.499999999921)); +#4222 = SURFACE_CURVE('',#4223,(#4227,#4234),.PCURVE_S1.); +#4223 = LINE('',#4224,#4225); +#4224 = CARTESIAN_POINT('',(23.000000000021,63.100000000005, + 4.499999999921)); +#4225 = VECTOR('',#4226,1.); +#4226 = DIRECTION('',(1.428931420621E-12,1.,-1.224646779457E-16)); +#4227 = PCURVE('',#2628,#4228); +#4228 = DEFINITIONAL_REPRESENTATION('',(#4229),#4233); +#4229 = LINE('',#4230,#4231); +#4230 = CARTESIAN_POINT('',(108.54999999993,127.7000000001)); +#4231 = VECTOR('',#4232,1.); +#4232 = DIRECTION('',(-1.013341774238E-14,1.)); +#4233 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4234 = PCURVE('',#4235,#4240); +#4235 = PLANE('',#4236); +#4236 = AXIS2_PLACEMENT_3D('',#4237,#4238,#4239); +#4237 = CARTESIAN_POINT('',(23.000000000023,64.600000000005,38.5)); +#4238 = DIRECTION('',(1.,-1.428931420621E-12,1.337243554735E-27)); +#4239 = DIRECTION('',(-1.428931420621E-12,-1.,-1.475342777831E-16)); +#4240 = DEFINITIONAL_REPRESENTATION('',(#4241),#4245); +#4241 = LINE('',#4242,#4243); +#4242 = CARTESIAN_POINT('',(1.5,34.000000000079)); +#4243 = VECTOR('',#4244,1.); +#4244 = DIRECTION('',(-1.,2.699989557288E-16)); +#4245 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4246 = ORIENTED_EDGE('',*,*,#4247,.F.); +#4247 = EDGE_CURVE('',#2728,#4220,#4248,.T.); +#4248 = SURFACE_CURVE('',#4249,(#4253,#4260),.PCURVE_S1.); +#4249 = LINE('',#4250,#4251); +#4250 = CARTESIAN_POINT('',(64.449999999996,62.599999999996, + 4.499999999978)); +#4251 = VECTOR('',#4252,1.); +#4252 = DIRECTION('',(1.,4.212228277711E-15,1.373715955813E-12)); +#4253 = PCURVE('',#2628,#4254); +#4254 = DEFINITIONAL_REPRESENTATION('',(#4255),#4259); +#4255 = LINE('',#4256,#4257); +#4256 = CARTESIAN_POINT('',(149.9999999999,127.20000000016)); +#4257 = VECTOR('',#4258,1.); +#4258 = DIRECTION('',(1.,1.443277066641E-12)); +#4259 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4260 = PCURVE('',#2766,#4261); +#4261 = DEFINITIONAL_REPRESENTATION('',(#4262),#4266); +#4262 = LINE('',#4263,#4264); +#4263 = CARTESIAN_POINT('',(13.650000000009,87.15000000001)); +#4264 = VECTOR('',#4265,1.); +#4265 = DIRECTION('',(-1.373715955813E-12,1.)); +#4266 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4267 = ORIENTED_EDGE('',*,*,#2727,.F.); +#4268 = FACE_BOUND('',#4269,.T.); +#4269 = EDGE_LOOP('',(#4270)); +#4270 = ORIENTED_EDGE('',*,*,#4271,.F.); +#4271 = EDGE_CURVE('',#4272,#4272,#4274,.T.); +#4272 = VERTEX_POINT('',#4273); +#4273 = CARTESIAN_POINT('',(-31.05000000007,61.599999999999, + 4.499999999925)); +#4274 = SURFACE_CURVE('',#4275,(#4280,#4291),.PCURVE_S1.); +#4275 = CIRCLE('',#4276,1.05); +#4276 = AXIS2_PLACEMENT_3D('',#4277,#4278,#4279); +#4277 = CARTESIAN_POINT('',(-30.00000000007,61.6,4.499999999925)); +#4278 = DIRECTION('',(-1.373715955813E-12,-1.224646799208E-16,-1.)); +#4279 = DIRECTION('',(1.,1.443734394282E-12,-1.373715955813E-12)); +#4280 = PCURVE('',#2628,#4281); +#4281 = DEFINITIONAL_REPRESENTATION('',(#4282),#4290); +#4282 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#4283,#4284,#4285,#4286, +#4287,#4288,#4289),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#4283 = CARTESIAN_POINT('',(56.59999999984,126.20000000003)); +#4284 = CARTESIAN_POINT('',(56.599999999846,124.38134665208)); +#4285 = CARTESIAN_POINT('',(55.024999999843,125.29067332605)); +#4286 = CARTESIAN_POINT('',(53.44999999984,126.20000000002)); +#4287 = CARTESIAN_POINT('',(55.024999999838,127.109326674)); +#4288 = CARTESIAN_POINT('',(56.599999999835,128.01865334797)); +#4289 = CARTESIAN_POINT('',(56.59999999984,126.20000000003)); +#4290 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4291 = PCURVE('',#4292,#4297); +#4292 = CYLINDRICAL_SURFACE('',#4293,1.05); +#4293 = AXIS2_PLACEMENT_3D('',#4294,#4295,#4296); +#4294 = CARTESIAN_POINT('',(-30.00000000007,61.6,38.5)); +#4295 = DIRECTION('',(-1.567230213877E-27,6.669143989382E-17,-1.)); +#4296 = DIRECTION('',(1.,1.443734394282E-12,-1.470945488298E-27)); +#4297 = DEFINITIONAL_REPRESENTATION('',(#4298),#4302); +#4298 = LINE('',#4299,#4300); +#4299 = CARTESIAN_POINT('',(-6.28318530718,34.000000000073)); +#4300 = VECTOR('',#4301,1.); +#4301 = DIRECTION('',(1.,0.)); +#4302 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4303 = FACE_BOUND('',#4304,.T.); +#4304 = EDGE_LOOP('',(#4305)); +#4305 = ORIENTED_EDGE('',*,*,#4306,.F.); +#4306 = EDGE_CURVE('',#4307,#4307,#4309,.T.); +#4307 = VERTEX_POINT('',#4308); +#4308 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011, + 4.499999999925)); +#4309 = SURFACE_CURVE('',#4310,(#4315,#4326),.PCURVE_S1.); +#4310 = CIRCLE('',#4311,1.05); +#4311 = AXIS2_PLACEMENT_3D('',#4312,#4313,#4314); +#4312 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011, + 4.499999999925)); +#4313 = DIRECTION('',(1.373715955813E-12,-1.833155449138E-15,-1.)); +#4314 = DIRECTION('',(-1.,-2.518234889967E-27,-1.373715955813E-12)); +#4315 = PCURVE('',#2628,#4316); +#4316 = DEFINITIONAL_REPRESENTATION('',(#4317),#4325); +#4317 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#4318,#4319,#4320,#4321, +#4322,#4323,#4324),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#4318 = CARTESIAN_POINT('',(110.50000000002,2.999999999994)); +#4319 = CARTESIAN_POINT('',(110.50000000002,4.818653347941)); +#4320 = CARTESIAN_POINT('',(112.07500000002,3.90932667397)); +#4321 = CARTESIAN_POINT('',(113.65000000002,2.999999999999)); +#4322 = CARTESIAN_POINT('',(112.07500000002,2.090673326023)); +#4323 = CARTESIAN_POINT('',(110.50000000002,1.181346652047)); +#4324 = CARTESIAN_POINT('',(110.50000000002,2.999999999994)); +#4325 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4326 = PCURVE('',#4327,#4332); +#4327 = CYLINDRICAL_SURFACE('',#4328,1.05); +#4328 = AXIS2_PLACEMENT_3D('',#4329,#4330,#4331); +#4329 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,38.5)); +#4330 = DIRECTION('',(-6.616465975138E-29,-2.02231156697E-15,-1.)); +#4331 = DIRECTION('',(-1.,-2.691512941528E-42,6.616465975138E-29)); +#4332 = DEFINITIONAL_REPRESENTATION('',(#4333),#4337); +#4333 = LINE('',#4334,#4335); +#4334 = CARTESIAN_POINT('',(-6.28318530718,34.000000000073)); +#4335 = VECTOR('',#4336,1.); +#4336 = DIRECTION('',(1.,0.)); +#4337 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4338 = FACE_BOUND('',#4339,.T.); +#4339 = EDGE_LOOP('',(#4340)); +#4340 = ORIENTED_EDGE('',*,*,#4341,.T.); +#4341 = EDGE_CURVE('',#4342,#4342,#4344,.T.); +#4342 = VERTEX_POINT('',#4343); +#4343 = CARTESIAN_POINT('',(-31.05000000016,-61.60000000003, + 4.499999999925)); +#4344 = SURFACE_CURVE('',#4345,(#4350,#4357),.PCURVE_S1.); +#4345 = CIRCLE('',#4346,1.05); +#4346 = AXIS2_PLACEMENT_3D('',#4347,#4348,#4349); +#4347 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003, + 4.499999999925)); +#4348 = DIRECTION('',(1.373715955813E-12,1.833155445184E-15,1.)); +#4349 = DIRECTION('',(1.,-2.878587004368E-12,-1.373715955813E-12)); +#4350 = PCURVE('',#2628,#4351); +#4351 = DEFINITIONAL_REPRESENTATION('',(#4352),#4356); +#4352 = CIRCLE('',#4353,1.05); +#4353 = AXIS2_PLACEMENT_2D('',#4354,#4355); +#4354 = CARTESIAN_POINT('',(55.549999999929,2.999999999996)); +#4355 = DIRECTION('',(1.,-1.439522166005E-12)); +#4356 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4357 = PCURVE('',#4358,#4363); +#4358 = CYLINDRICAL_SURFACE('',#4359,1.05); +#4359 = AXIS2_PLACEMENT_3D('',#4360,#4361,#4362); +#4360 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003,38.5)); +#4361 = DIRECTION('',(3.065935922314E-27,2.02231156697E-15,1.)); +#4362 = DIRECTION('',(1.,-2.878587004368E-12,2.755463873147E-27)); +#4363 = DEFINITIONAL_REPRESENTATION('',(#4364),#4368); +#4364 = LINE('',#4365,#4366); +#4365 = CARTESIAN_POINT('',(-6.28318530718,-34.00000000007)); +#4366 = VECTOR('',#4367,1.); +#4367 = DIRECTION('',(1.,0.)); +#4368 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4369 = FACE_BOUND('',#4370,.T.); +#4370 = EDGE_LOOP('',(#4371)); +#4371 = ORIENTED_EDGE('',*,*,#4372,.T.); +#4372 = EDGE_CURVE('',#4373,#4373,#4375,.T.); +#4373 = VERTEX_POINT('',#4374); +#4374 = CARTESIAN_POINT('',(27.050000000019,61.599999999999, + 4.499999999925)); +#4375 = SURFACE_CURVE('',#4376,(#4381,#4388),.PCURVE_S1.); +#4376 = CIRCLE('',#4377,1.05); +#4377 = AXIS2_PLACEMENT_3D('',#4378,#4379,#4380); +#4378 = CARTESIAN_POINT('',(26.000000000019,61.6,4.499999999925)); +#4379 = DIRECTION('',(-1.373715955813E-12,1.224646799086E-16,1.)); +#4380 = DIRECTION('',(-1.,1.434852610085E-12,-1.373715955813E-12)); +#4381 = PCURVE('',#2628,#4382); +#4382 = DEFINITIONAL_REPRESENTATION('',(#4383),#4387); +#4383 = CIRCLE('',#4384,1.05); +#4384 = AXIS2_PLACEMENT_2D('',#4385,#4386); +#4385 = CARTESIAN_POINT('',(111.54999999993,126.2000000001)); +#4386 = DIRECTION('',(-1.,-4.21222827771E-15)); +#4387 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4388 = PCURVE('',#4389,#4394); +#4389 = CYLINDRICAL_SURFACE('',#4390,1.05); +#4390 = AXIS2_PLACEMENT_3D('',#4391,#4392,#4393); +#4391 = CARTESIAN_POINT('',(26.000000000019,61.6,38.5)); +#4392 = DIRECTION('',(-1.432541048686E-27,-6.669143989382E-17,1.)); +#4393 = DIRECTION('',(-1.,1.434852610085E-12,-1.336848662084E-27)); +#4394 = DEFINITIONAL_REPRESENTATION('',(#4395),#4399); +#4395 = LINE('',#4396,#4397); +#4396 = CARTESIAN_POINT('',(-6.661338147751E-15,-34.00000000007)); +#4397 = VECTOR('',#4398,1.); +#4398 = DIRECTION('',(1.,0.)); +#4399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4400 = ADVANCED_FACE('',(#4401),#4207,.T.); +#4401 = FACE_BOUND('',#4402,.T.); +#4402 = EDGE_LOOP('',(#4403,#4404,#4427,#4451)); +#4403 = ORIENTED_EDGE('',*,*,#4190,.T.); +#4404 = ORIENTED_EDGE('',*,*,#4405,.T.); +#4405 = EDGE_CURVE('',#4163,#4406,#4408,.T.); +#4406 = VERTEX_POINT('',#4407); +#4407 = CARTESIAN_POINT('',(26.000000000014,58.6,36.5)); +#4408 = SURFACE_CURVE('',#4409,(#4413,#4420),.PCURVE_S1.); +#4409 = LINE('',#4410,#4411); +#4410 = CARTESIAN_POINT('',(26.000000000014,58.6,38.5)); +#4411 = VECTOR('',#4412,1.); +#4412 = DIRECTION('',(-1.432541048686E-27,-6.669143989382E-17,1.)); +#4413 = PCURVE('',#4207,#4414); +#4414 = DEFINITIONAL_REPRESENTATION('',(#4415),#4419); +#4415 = LINE('',#4416,#4417); +#4416 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#4417 = VECTOR('',#4418,1.); +#4418 = DIRECTION('',(-5.551115123113E-17,-1.)); +#4419 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4420 = PCURVE('',#4178,#4421); +#4421 = DEFINITIONAL_REPRESENTATION('',(#4422),#4426); +#4422 = LINE('',#4423,#4424); +#4423 = CARTESIAN_POINT('',(3.,-4.509315221511E-28)); +#4424 = VECTOR('',#4425,1.); +#4425 = DIRECTION('',(-1.420964917647E-27,-1.)); +#4426 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4427 = ORIENTED_EDGE('',*,*,#4428,.F.); +#4428 = EDGE_CURVE('',#4429,#4406,#4431,.T.); +#4429 = VERTEX_POINT('',#4430); +#4430 = CARTESIAN_POINT('',(23.000000000019,61.600000000005,36.5)); +#4431 = SURFACE_CURVE('',#4432,(#4437,#4444),.PCURVE_S1.); +#4432 = CIRCLE('',#4433,3.); +#4433 = AXIS2_PLACEMENT_3D('',#4434,#4435,#4436); +#4434 = CARTESIAN_POINT('',(26.000000000019,61.6,36.5)); +#4435 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#4436 = DIRECTION('',(-0.707106781188,-0.707106781186,5.510697266631E-16 + )); +#4437 = PCURVE('',#4207,#4438); +#4438 = DEFINITIONAL_REPRESENTATION('',(#4439),#4443); +#4439 = LINE('',#4440,#4441); +#4440 = CARTESIAN_POINT('',(6.28318530718,2.)); +#4441 = VECTOR('',#4442,1.); +#4442 = DIRECTION('',(-1.,-4.52345554697E-15)); +#4443 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4444 = PCURVE('',#2685,#4445); +#4445 = DEFINITIONAL_REPRESENTATION('',(#4446),#4450); +#4446 = CIRCLE('',#4447,3.); +#4447 = AXIS2_PLACEMENT_2D('',#4448,#4449); +#4448 = CARTESIAN_POINT('',(28.000000000009,61.600000000002)); +#4449 = DIRECTION('',(-0.707106781188,-0.707106781186)); +#4450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4451 = ORIENTED_EDGE('',*,*,#4452,.T.); +#4452 = EDGE_CURVE('',#4429,#4191,#4453,.T.); +#4453 = SURFACE_CURVE('',#4454,(#4458,#4465),.PCURVE_S1.); +#4454 = LINE('',#4455,#4456); +#4455 = CARTESIAN_POINT('',(23.000000000019,61.600000000005,38.5)); +#4456 = VECTOR('',#4457,1.); +#4457 = DIRECTION('',(1.432541048686E-27,6.669143989382E-17,-1.)); +#4458 = PCURVE('',#4207,#4459); +#4459 = DEFINITIONAL_REPRESENTATION('',(#4460),#4464); +#4460 = LINE('',#4461,#4462); +#4461 = CARTESIAN_POINT('',(0.785398163397,0.)); +#4462 = VECTOR('',#4463,1.); +#4463 = DIRECTION('',(-8.326672684668E-17,1.)); +#4464 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4465 = PCURVE('',#4235,#4466); +#4466 = DEFINITIONAL_REPRESENTATION('',(#4467),#4471); +#4467 = LINE('',#4468,#4469); +#4468 = CARTESIAN_POINT('',(3.,-4.426028333493E-16)); +#4469 = VECTOR('',#4470,1.); +#4470 = DIRECTION('',(8.084283788926E-17,1.)); +#4471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4472 = ADVANCED_FACE('',(#4473),#4178,.F.); +#4473 = FACE_BOUND('',#4474,.T.); +#4474 = EDGE_LOOP('',(#4475,#4476,#4477,#4500)); +#4475 = ORIENTED_EDGE('',*,*,#4405,.F.); +#4476 = ORIENTED_EDGE('',*,*,#4162,.F.); +#4477 = ORIENTED_EDGE('',*,*,#4478,.F.); +#4478 = EDGE_CURVE('',#4479,#4135,#4481,.T.); +#4479 = VERTEX_POINT('',#4480); +#4480 = CARTESIAN_POINT('',(27.000000000023,58.599999999999,36.5)); +#4481 = SURFACE_CURVE('',#4482,(#4486,#4493),.PCURVE_S1.); +#4482 = LINE('',#4483,#4484); +#4483 = CARTESIAN_POINT('',(27.000000000023,58.599999999999,21.5)); +#4484 = VECTOR('',#4485,1.); +#4485 = DIRECTION('',(-6.663278342077E-29,6.669143989382E-17,-1.)); +#4486 = PCURVE('',#4178,#4487); +#4487 = DEFINITIONAL_REPRESENTATION('',(#4488),#4492); +#4488 = LINE('',#4489,#4490); +#4489 = CARTESIAN_POINT('',(4.000000000009,17.)); +#4490 = VECTOR('',#4491,1.); +#4491 = DIRECTION('',(-7.820891445941E-29,1.)); +#4492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4493 = PCURVE('',#4150,#4494); +#4494 = DEFINITIONAL_REPRESENTATION('',(#4495),#4499); +#4495 = LINE('',#4496,#4497); +#4496 = CARTESIAN_POINT('',(123.19999999999,17.)); +#4497 = VECTOR('',#4498,1.); +#4498 = DIRECTION('',(1.891561198086E-16,-1.)); +#4499 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4500 = ORIENTED_EDGE('',*,*,#4501,.F.); +#4501 = EDGE_CURVE('',#4406,#4479,#4502,.T.); +#4502 = SURFACE_CURVE('',#4503,(#4507,#4514),.PCURVE_S1.); +#4503 = LINE('',#4504,#4505); +#4504 = CARTESIAN_POINT('',(10.500000000054,58.600000000023,36.5)); +#4505 = VECTOR('',#4506,1.); +#4506 = DIRECTION('',(1.,-1.434852610085E-12,1.018942737709E-15)); +#4507 = PCURVE('',#4178,#4508); +#4508 = DEFINITIONAL_REPRESENTATION('',(#4509),#4513); +#4509 = LINE('',#4510,#4511); +#4510 = CARTESIAN_POINT('',(-12.49999999996,2.)); +#4511 = VECTOR('',#4512,1.); +#4512 = DIRECTION('',(1.,-1.018942737709E-15)); +#4513 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4514 = PCURVE('',#2685,#4515); +#4515 = DEFINITIONAL_REPRESENTATION('',(#4516),#4520); +#4516 = LINE('',#4517,#4518); +#4517 = CARTESIAN_POINT('',(12.500000000045,58.600000000024)); +#4518 = VECTOR('',#4519,1.); +#4519 = DIRECTION('',(1.,-1.434852610085E-12)); +#4520 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4521 = ADVANCED_FACE('',(#4522),#3073,.F.); +#4522 = FACE_BOUND('',#4523,.F.); +#4523 = EDGE_LOOP('',(#4524,#4547,#4548,#4571)); +#4524 = ORIENTED_EDGE('',*,*,#4525,.F.); +#4525 = EDGE_CURVE('',#3025,#4526,#4528,.T.); +#4526 = VERTEX_POINT('',#4527); +#4527 = CARTESIAN_POINT('',(-23.99999999994,35.599999999997, + 30.149999999944)); +#4528 = SURFACE_CURVE('',#4529,(#4533,#4540),.PCURVE_S1.); +#4529 = LINE('',#4530,#4531); +#4530 = CARTESIAN_POINT('',(-23.99999999994,35.599999999997,13.)); +#4531 = VECTOR('',#4532,1.); +#4532 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#4533 = PCURVE('',#3073,#4534); +#4534 = DEFINITIONAL_REPRESENTATION('',(#4535),#4539); +#4535 = LINE('',#4536,#4537); +#4536 = CARTESIAN_POINT('',(-0.785398163398,0.)); +#4537 = VECTOR('',#4538,1.); +#4538 = DIRECTION('',(0.,1.)); +#4539 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4540 = PCURVE('',#3040,#4541); +#4541 = DEFINITIONAL_REPRESENTATION('',(#4542),#4546); +#4542 = LINE('',#4543,#4544); +#4543 = CARTESIAN_POINT('',(-8.5,25.150000000059)); +#4544 = VECTOR('',#4545,1.); +#4545 = DIRECTION('',(1.,-8.968310171679E-44)); +#4546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4547 = ORIENTED_EDGE('',*,*,#3052,.F.); +#4548 = ORIENTED_EDGE('',*,*,#4549,.F.); +#4549 = EDGE_CURVE('',#4550,#3053,#4552,.T.); +#4550 = VERTEX_POINT('',#4551); +#4551 = CARTESIAN_POINT('',(-22.99999999994,36.599999999997, + 29.149999999943)); +#4552 = SURFACE_CURVE('',#4553,(#4557,#4564),.PCURVE_S1.); +#4553 = LINE('',#4554,#4555); +#4554 = CARTESIAN_POINT('',(-22.99999999994,36.599999999997,13.)); +#4555 = VECTOR('',#4556,1.); +#4556 = DIRECTION('',(-6.616465975138E-29,-9.778100635379E-16,-1.)); +#4557 = PCURVE('',#3073,#4558); +#4558 = DEFINITIONAL_REPRESENTATION('',(#4559),#4563); +#4559 = LINE('',#4560,#4561); +#4560 = CARTESIAN_POINT('',(0.785398163398,0.)); +#4561 = VECTOR('',#4562,1.); +#4562 = DIRECTION('',(0.,-1.)); +#4563 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4564 = PCURVE('',#3101,#4565); +#4565 = DEFINITIONAL_REPRESENTATION('',(#4566),#4570); +#4566 = LINE('',#4567,#4568); +#4567 = CARTESIAN_POINT('',(1.999999999999,8.5)); +#4568 = VECTOR('',#4569,1.); +#4569 = DIRECTION('',(8.553453836232E-16,-1.)); +#4570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4571 = ORIENTED_EDGE('',*,*,#4572,.F.); +#4572 = EDGE_CURVE('',#4526,#4550,#4573,.T.); +#4573 = SURFACE_CURVE('',#4574,(#4579,#4608),.PCURVE_S1.); +#4574 = ELLIPSE('',#4575,1.414213562373,1.); +#4575 = AXIS2_PLACEMENT_3D('',#4576,#4577,#4578); +#4576 = CARTESIAN_POINT('',(-23.99999999994,36.599999999997, + 30.149999999943)); +#4577 = DIRECTION('',(0.707106781187,5.623574421305E-13,0.707106781187) + ); +#4578 = DIRECTION('',(0.707106781187,5.610742622058E-13,-0.707106781187) + ); +#4579 = PCURVE('',#3073,#4580); +#4580 = DEFINITIONAL_REPRESENTATION('',(#4581),#4607); +#4581 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#4582,#4583,#4584,#4585,#4586, + #4587,#4588,#4589,#4590,#4591,#4592,#4593,#4594,#4595,#4596,#4597, + #4598,#4599,#4600,#4601,#4602,#4603,#4604,#4605,#4606), + .UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4), + (4.712388980383,4.783788813419,4.855188646456,4.926588479492, + 4.997988312528,5.069388145564,5.1407879786,5.212187811637, + 5.283587644673,5.354987477709,5.426387310745,5.497787143781, + 5.569186976818,5.640586809854,5.71198664289,5.783386475926, + 5.854786308962,5.926186141999,5.997585975035,6.068985808071, + 6.140385641107,6.211785474143,6.28318530718),.QUASI_UNIFORM_KNOTS.); +#4582 = CARTESIAN_POINT('',(-0.785398163398,17.149999999944)); +#4583 = CARTESIAN_POINT('',(-0.761598219052,17.126199870376)); +#4584 = CARTESIAN_POINT('',(-0.713998330362,17.078600264781)); +#4585 = CARTESIAN_POINT('',(-0.642598497325,17.007564168171)); +#4586 = CARTESIAN_POINT('',(-0.571198664289,16.937254032558)); +#4587 = CARTESIAN_POINT('',(-0.499798831253,16.868027963942)); +#4588 = CARTESIAN_POINT('',(-0.428398998217,16.800238770287)); +#4589 = CARTESIAN_POINT('',(-0.356999165181,16.734231876979)); +#4590 = CARTESIAN_POINT('',(-0.285599332144,16.670343643448)); +#4591 = CARTESIAN_POINT('',(-0.214199499108,16.608899628569)); +#4592 = CARTESIAN_POINT('',(-0.142799666072,16.550212937203)); +#4593 = CARTESIAN_POINT('',(-7.139983303581E-02,16.494582623211)); +#4594 = CARTESIAN_POINT('',(3.839664029642E-13,16.442292165942)); +#4595 = CARTESIAN_POINT('',(7.139983303658E-02,16.393608025562)); +#4596 = CARTESIAN_POINT('',(0.142799666073,16.348778285345)); +#4597 = CARTESIAN_POINT('',(0.214199499109,16.30803138717)); +#4598 = CARTESIAN_POINT('',(0.285599332145,16.271574968645)); +#4599 = CARTESIAN_POINT('',(0.356999165181,16.239594800505)); +#4600 = CARTESIAN_POINT('',(0.428398998218,16.212253856865)); +#4601 = CARTESIAN_POINT('',(0.499798831254,16.189691421691)); +#4602 = CARTESIAN_POINT('',(0.57119866429,16.172022614338)); +#4603 = CARTESIAN_POINT('',(0.642598497326,16.159336924784)); +#4604 = CARTESIAN_POINT('',(0.713998330362,16.151701034894)); +#4605 = CARTESIAN_POINT('',(0.761598219053,16.149997843387)); +#4606 = CARTESIAN_POINT('',(0.785398163399,16.149999999943)); +#4607 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4608 = PCURVE('',#4609,#4614); +#4609 = PLANE('',#4610); +#4610 = AXIS2_PLACEMENT_3D('',#4611,#4612,#4613); +#4611 = CARTESIAN_POINT('',(-22.99999999995,-30.29999999999,29.15)); +#4612 = DIRECTION('',(0.707106781187,5.623574421305E-13,0.707106781187) + ); +#4613 = DIRECTION('',(-0.707106781187,-5.605173418255E-13,0.707106781187 + )); +#4614 = DEFINITIONAL_REPRESENTATION('',(#4615),#4619); +#4615 = ELLIPSE('',#4616,1.414213562373,1.); +#4616 = AXIS2_PLACEMENT_2D('',#4617,#4618); +#4617 = CARTESIAN_POINT('',(1.414213562292,-66.89999999999)); +#4618 = DIRECTION('',(-1.,-5.569203802721E-16)); +#4619 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4620 = ADVANCED_FACE('',(#4621),#3101,.T.); +#4621 = FACE_BOUND('',#4622,.T.); +#4622 = EDGE_LOOP('',(#4623,#4624,#4647,#4670,#4698,#4721,#4749,#4770, + #4771,#4794,#4822,#4843)); +#4623 = ORIENTED_EDGE('',*,*,#4549,.F.); +#4624 = ORIENTED_EDGE('',*,*,#4625,.T.); +#4625 = EDGE_CURVE('',#4550,#4626,#4628,.T.); +#4626 = VERTEX_POINT('',#4627); +#4627 = CARTESIAN_POINT('',(-22.99999999994,31.135898384894, + 29.149999999947)); +#4628 = SURFACE_CURVE('',#4629,(#4633,#4640),.PCURVE_S1.); +#4629 = LINE('',#4630,#4631); +#4630 = CARTESIAN_POINT('',(-22.99999999994,4.150000000008, + 29.149999999969)); +#4631 = VECTOR('',#4632,1.); +#4632 = DIRECTION('',(5.261222242278E-41,-1.,7.952935215625E-13)); +#4633 = PCURVE('',#3101,#4634); +#4634 = DEFINITIONAL_REPRESENTATION('',(#4635),#4639); +#4635 = LINE('',#4636,#4637); +#4636 = CARTESIAN_POINT('',(34.449999999988,24.649999999968)); +#4637 = VECTOR('',#4638,1.); +#4638 = DIRECTION('',(1.,7.951710568825E-13)); +#4639 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4640 = PCURVE('',#4609,#4641); +#4641 = DEFINITIONAL_REPRESENTATION('',(#4642),#4646); +#4642 = LINE('',#4643,#4644); +#4643 = CARTESIAN_POINT('',(-4.462976145161E-11,-34.45)); +#4644 = VECTOR('',#4645,1.); +#4645 = DIRECTION('',(1.122874783956E-12,1.)); +#4646 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4647 = ORIENTED_EDGE('',*,*,#4648,.F.); +#4648 = EDGE_CURVE('',#4649,#4626,#4651,.T.); +#4649 = VERTEX_POINT('',#4650); +#4650 = CARTESIAN_POINT('',(-22.99999999994,31.135898384894,33.5)); +#4651 = SURFACE_CURVE('',#4652,(#4656,#4663),.PCURVE_S1.); +#4652 = LINE('',#4653,#4654); +#4653 = CARTESIAN_POINT('',(-22.99999999994,31.135898384894,4.5)); +#4654 = VECTOR('',#4655,1.); +#4655 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#4656 = PCURVE('',#3101,#4657); +#4657 = DEFINITIONAL_REPRESENTATION('',(#4658),#4662); +#4658 = LINE('',#4659,#4660); +#4659 = CARTESIAN_POINT('',(7.464101615102,-9.140888151446E-16)); +#4660 = VECTOR('',#4661,1.); +#4661 = DIRECTION('',(0.,-1.)); +#4662 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4663 = PCURVE('',#2956,#4664); +#4664 = DEFINITIONAL_REPRESENTATION('',(#4665),#4669); +#4665 = LINE('',#4666,#4667); +#4666 = CARTESIAN_POINT('',(0.261799387799,0.)); +#4667 = VECTOR('',#4668,1.); +#4668 = DIRECTION('',(0.,1.)); +#4669 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4670 = ORIENTED_EDGE('',*,*,#4671,.F.); +#4671 = EDGE_CURVE('',#4672,#4649,#4674,.T.); +#4672 = VERTEX_POINT('',#4673); +#4673 = CARTESIAN_POINT('',(-22.99999999994,-31.13589838486,33.5)); +#4674 = SURFACE_CURVE('',#4675,(#4679,#4686),.PCURVE_S1.); +#4675 = LINE('',#4676,#4677); +#4676 = CARTESIAN_POINT('',(-22.99999999994,34.600000000014,33.5)); +#4677 = VECTOR('',#4678,1.); +#4678 = DIRECTION('',(4.45098715844E-61,1.,-1.224646799147E-16)); +#4679 = PCURVE('',#3101,#4680); +#4680 = DEFINITIONAL_REPRESENTATION('',(#4681),#4685); +#4681 = LINE('',#4682,#4683); +#4682 = CARTESIAN_POINT('',(3.999999999982,29.)); +#4683 = VECTOR('',#4684,1.); +#4684 = DIRECTION('',(-1.,0.)); +#4685 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4686 = PCURVE('',#4687,#4692); +#4687 = PLANE('',#4688); +#4688 = AXIS2_PLACEMENT_3D('',#4689,#4690,#4691); +#4689 = CARTESIAN_POINT('',(-22.99999999994,30.600000000031,33.5)); +#4690 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#4691 = DIRECTION('',(-2.228967694695E-42,-1.,1.224646799147E-16)); +#4692 = DEFINITIONAL_REPRESENTATION('',(#4693),#4697); +#4693 = LINE('',#4694,#4695); +#4694 = CARTESIAN_POINT('',(-3.999999999982,-8.948282114252E-42)); +#4695 = VECTOR('',#4696,1.); +#4696 = DIRECTION('',(-1.,-2.228967694695E-42)); +#4697 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4698 = ORIENTED_EDGE('',*,*,#4699,.F.); +#4699 = EDGE_CURVE('',#4700,#4672,#4702,.T.); +#4700 = VERTEX_POINT('',#4701); +#4701 = CARTESIAN_POINT('',(-22.99999999994,-31.13589838486, + 29.149999999997)); +#4702 = SURFACE_CURVE('',#4703,(#4707,#4714),.PCURVE_S1.); +#4703 = LINE('',#4704,#4705); +#4704 = CARTESIAN_POINT('',(-22.99999999994,-31.13589838486,4.5)); +#4705 = VECTOR('',#4706,1.); +#4706 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#4707 = PCURVE('',#3101,#4708); +#4708 = DEFINITIONAL_REPRESENTATION('',(#4709),#4713); +#4709 = LINE('',#4710,#4711); +#4710 = CARTESIAN_POINT('',(69.735898384857,-8.540184474268E-15)); +#4711 = VECTOR('',#4712,1.); +#4712 = DIRECTION('',(0.,1.)); +#4713 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4714 = PCURVE('',#3706,#4715); +#4715 = DEFINITIONAL_REPRESENTATION('',(#4716),#4720); +#4716 = LINE('',#4717,#4718); +#4717 = CARTESIAN_POINT('',(6.544984694979,0.)); +#4718 = VECTOR('',#4719,1.); +#4719 = DIRECTION('',(0.,1.)); +#4720 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4721 = ORIENTED_EDGE('',*,*,#4722,.T.); +#4722 = EDGE_CURVE('',#4700,#4723,#4725,.T.); +#4723 = VERTEX_POINT('',#4724); +#4724 = CARTESIAN_POINT('',(-22.99999999994,-36.6,29.150000000001)); +#4725 = SURFACE_CURVE('',#4726,(#4730,#4737),.PCURVE_S1.); +#4726 = LINE('',#4727,#4728); +#4727 = CARTESIAN_POINT('',(-22.99999999994,4.150000000008, + 29.149999999969)); +#4728 = VECTOR('',#4729,1.); +#4729 = DIRECTION('',(5.261222242278E-41,-1.,7.952935215625E-13)); +#4730 = PCURVE('',#3101,#4731); +#4731 = DEFINITIONAL_REPRESENTATION('',(#4732),#4736); +#4732 = LINE('',#4733,#4734); +#4733 = CARTESIAN_POINT('',(34.449999999988,24.649999999968)); +#4734 = VECTOR('',#4735,1.); +#4735 = DIRECTION('',(1.,7.951710568825E-13)); +#4736 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4737 = PCURVE('',#4738,#4743); +#4738 = PLANE('',#4739); +#4739 = AXIS2_PLACEMENT_3D('',#4740,#4741,#4742); +#4740 = CARTESIAN_POINT('',(-22.99999999995,-30.29999999999,29.15)); +#4741 = DIRECTION('',(0.707106781187,5.623574421305E-13,0.707106781187) + ); +#4742 = DIRECTION('',(-0.707106781187,-5.605173418255E-13,0.707106781187 + )); +#4743 = DEFINITIONAL_REPRESENTATION('',(#4744),#4748); +#4744 = LINE('',#4745,#4746); +#4745 = CARTESIAN_POINT('',(-4.462976145161E-11,-34.45)); +#4746 = VECTOR('',#4747,1.); +#4747 = DIRECTION('',(1.122874783956E-12,1.)); +#4748 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4749 = ORIENTED_EDGE('',*,*,#4750,.F.); +#4750 = EDGE_CURVE('',#3550,#4723,#4751,.T.); +#4751 = SURFACE_CURVE('',#4752,(#4756,#4763),.PCURVE_S1.); +#4752 = LINE('',#4753,#4754); +#4753 = CARTESIAN_POINT('',(-22.99999999994,-36.6,13.)); +#4754 = VECTOR('',#4755,1.); +#4755 = DIRECTION('',(6.616465975138E-29,1.112809542387E-15,1.)); +#4756 = PCURVE('',#3101,#4757); +#4757 = DEFINITIONAL_REPRESENTATION('',(#4758),#4762); +#4758 = LINE('',#4759,#4760); +#4759 = CARTESIAN_POINT('',(75.199999999996,8.5)); +#4760 = VECTOR('',#4761,1.); +#4761 = DIRECTION('',(-9.903448624721E-16,1.)); +#4762 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4763 = PCURVE('',#3593,#4764); +#4764 = DEFINITIONAL_REPRESENTATION('',(#4765),#4769); +#4765 = LINE('',#4766,#4767); +#4766 = CARTESIAN_POINT('',(0.785398163398,0.)); +#4767 = VECTOR('',#4768,1.); +#4768 = DIRECTION('',(4.954342097719E-17,-1.)); +#4769 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4770 = ORIENTED_EDGE('',*,*,#3549,.T.); +#4771 = ORIENTED_EDGE('',*,*,#4772,.F.); +#4772 = EDGE_CURVE('',#4773,#3517,#4775,.T.); +#4773 = VERTEX_POINT('',#4774); +#4774 = CARTESIAN_POINT('',(-22.99999999994,-37.59999999999,38.5)); +#4775 = SURFACE_CURVE('',#4776,(#4780,#4787),.PCURVE_S1.); +#4776 = LINE('',#4777,#4778); +#4777 = CARTESIAN_POINT('',(-22.99999999994,-37.59999999999,4.5)); +#4778 = VECTOR('',#4779,1.); +#4779 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#4780 = PCURVE('',#3101,#4781); +#4781 = DEFINITIONAL_REPRESENTATION('',(#4782),#4786); +#4782 = LINE('',#4783,#4784); +#4783 = CARTESIAN_POINT('',(76.199999999995,-9.331808609502E-15)); +#4784 = VECTOR('',#4785,1.); +#4785 = DIRECTION('',(0.,-1.)); +#4786 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4787 = PCURVE('',#3537,#4788); +#4788 = DEFINITIONAL_REPRESENTATION('',(#4789),#4793); +#4789 = LINE('',#4790,#4791); +#4790 = CARTESIAN_POINT('',(7.068583470577,0.)); +#4791 = VECTOR('',#4792,1.); +#4792 = DIRECTION('',(0.,-1.)); +#4793 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4794 = ORIENTED_EDGE('',*,*,#4795,.T.); +#4795 = EDGE_CURVE('',#4773,#4796,#4798,.T.); +#4796 = VERTEX_POINT('',#4797); +#4797 = CARTESIAN_POINT('',(-22.99999999994,37.599999999996,38.5)); +#4798 = SURFACE_CURVE('',#4799,(#4803,#4810),.PCURVE_S1.); +#4799 = LINE('',#4800,#4801); +#4800 = CARTESIAN_POINT('',(-22.99999999994,19.299999999997,38.5)); +#4801 = VECTOR('',#4802,1.); +#4802 = DIRECTION('',(-1.108792885622E-43,1.,-1.798273018971E-15)); +#4803 = PCURVE('',#3101,#4804); +#4804 = DEFINITIONAL_REPRESENTATION('',(#4805),#4809); +#4805 = LINE('',#4806,#4807); +#4806 = CARTESIAN_POINT('',(19.299999999999,34.)); +#4807 = VECTOR('',#4808,1.); +#4808 = DIRECTION('',(-1.,-1.675808339056E-15)); +#4809 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4810 = PCURVE('',#4811,#4816); +#4811 = PLANE('',#4812); +#4812 = AXIS2_PLACEMENT_3D('',#4813,#4814,#4815); +#4813 = CARTESIAN_POINT('',(28.99999999993,-64.60000000011,38.5)); +#4814 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#4815 = DIRECTION('',(-1.,1.439064838363E-12,-1.146036670582E-15)); +#4816 = DEFINITIONAL_REPRESENTATION('',(#4817),#4821); +#4817 = LINE('',#4818,#4819); +#4818 = CARTESIAN_POINT('',(52.,83.900000000036)); +#4819 = VECTOR('',#4820,1.); +#4820 = DIRECTION('',(1.439064838363E-12,1.)); +#4821 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4822 = ORIENTED_EDGE('',*,*,#4823,.F.); +#4823 = EDGE_CURVE('',#3086,#4796,#4824,.T.); +#4824 = SURFACE_CURVE('',#4825,(#4829,#4836),.PCURVE_S1.); +#4825 = LINE('',#4826,#4827); +#4826 = CARTESIAN_POINT('',(-22.99999999994,37.599999999996,4.5)); +#4827 = VECTOR('',#4828,1.); +#4828 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#4829 = PCURVE('',#3101,#4830); +#4830 = DEFINITIONAL_REPRESENTATION('',(#4831),#4835); +#4831 = LINE('',#4832,#4833); +#4832 = CARTESIAN_POINT('',(1.,-1.224646799147E-16)); +#4833 = VECTOR('',#4834,1.); +#4834 = DIRECTION('',(0.,1.)); +#4835 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4836 = PCURVE('',#3134,#4837); +#4837 = DEFINITIONAL_REPRESENTATION('',(#4838),#4842); +#4838 = LINE('',#4839,#4840); +#4839 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#4840 = VECTOR('',#4841,1.); +#4841 = DIRECTION('',(0.,1.)); +#4842 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4843 = ORIENTED_EDGE('',*,*,#3085,.T.); +#4844 = ADVANCED_FACE('',(#4845),#3134,.F.); +#4845 = FACE_BOUND('',#4846,.F.); +#4846 = EDGE_LOOP('',(#4847,#4870,#4896,#4897)); +#4847 = ORIENTED_EDGE('',*,*,#4848,.F.); +#4848 = EDGE_CURVE('',#4849,#3114,#4851,.T.); +#4849 = VERTEX_POINT('',#4850); +#4850 = CARTESIAN_POINT('',(-23.99999999994,38.599999999996,38.5)); +#4851 = SURFACE_CURVE('',#4852,(#4856,#4863),.PCURVE_S1.); +#4852 = LINE('',#4853,#4854); +#4853 = CARTESIAN_POINT('',(-23.99999999994,38.599999999996,4.5)); +#4854 = VECTOR('',#4855,1.); +#4855 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#4856 = PCURVE('',#3134,#4857); +#4857 = DEFINITIONAL_REPRESENTATION('',(#4858),#4862); +#4858 = LINE('',#4859,#4860); +#4859 = CARTESIAN_POINT('',(0.785398163397,0.)); +#4860 = VECTOR('',#4861,1.); +#4861 = DIRECTION('',(0.,-1.)); +#4862 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4863 = PCURVE('',#3162,#4864); +#4864 = DEFINITIONAL_REPRESENTATION('',(#4865),#4869); +#4865 = LINE('',#4866,#4867); +#4866 = CARTESIAN_POINT('',(9.000000000056,1.19444453108E-27)); +#4867 = VECTOR('',#4868,1.); +#4868 = DIRECTION('',(0.,-1.)); +#4869 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4870 = ORIENTED_EDGE('',*,*,#4871,.F.); +#4871 = EDGE_CURVE('',#4796,#4849,#4872,.T.); +#4872 = SURFACE_CURVE('',#4873,(#4878,#4885),.PCURVE_S1.); +#4873 = CIRCLE('',#4874,1.); +#4874 = AXIS2_PLACEMENT_3D('',#4875,#4876,#4877); +#4875 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996,38.5)); +#4876 = DIRECTION('',(-1.146036670579E-15,1.833155447163E-15,1.)); +#4877 = DIRECTION('',(0.707106781187,0.707106781187,-4.85866346403E-16) + ); +#4878 = PCURVE('',#3134,#4879); +#4879 = DEFINITIONAL_REPRESENTATION('',(#4880),#4884); +#4880 = LINE('',#4881,#4882); +#4881 = CARTESIAN_POINT('',(-6.28318530718,34.)); +#4882 = VECTOR('',#4883,1.); +#4883 = DIRECTION('',(1.,0.)); +#4884 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4885 = PCURVE('',#4811,#4886); +#4886 = DEFINITIONAL_REPRESENTATION('',(#4887),#4895); +#4887 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#4888,#4889,#4890,#4891, +#4892,#4893,#4894),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#4888 = CARTESIAN_POINT('',(52.292893218841,102.90710678122)); +#4889 = CARTESIAN_POINT('',(53.517638090234,104.13185165261)); +#4890 = CARTESIAN_POINT('',(53.965925826316,102.45881904513)); +#4891 = CARTESIAN_POINT('',(54.414213562397,100.78578643765)); +#4892 = CARTESIAN_POINT('',(52.741180954922,101.23407417374)); +#4893 = CARTESIAN_POINT('',(51.068148347447,101.68236190983)); +#4894 = CARTESIAN_POINT('',(52.292893218841,102.90710678122)); +#4895 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4896 = ORIENTED_EDGE('',*,*,#4823,.F.); +#4897 = ORIENTED_EDGE('',*,*,#3113,.F.); +#4898 = ADVANCED_FACE('',(#4899),#3593,.F.); +#4899 = FACE_BOUND('',#4900,.F.); +#4900 = EDGE_LOOP('',(#4901,#4902,#4903,#4926)); +#4901 = ORIENTED_EDGE('',*,*,#4750,.F.); +#4902 = ORIENTED_EDGE('',*,*,#3572,.F.); +#4903 = ORIENTED_EDGE('',*,*,#4904,.F.); +#4904 = EDGE_CURVE('',#4905,#3573,#4907,.T.); +#4905 = VERTEX_POINT('',#4906); +#4906 = CARTESIAN_POINT('',(-23.99999999995,-35.6,30.150000000001)); +#4907 = SURFACE_CURVE('',#4908,(#4912,#4919),.PCURVE_S1.); +#4908 = LINE('',#4909,#4910); +#4909 = CARTESIAN_POINT('',(-23.99999999995,-35.6,13.)); +#4910 = VECTOR('',#4911,1.); +#4911 = DIRECTION('',(-6.616465975138E-29,-1.112809542387E-15,-1.)); +#4912 = PCURVE('',#3593,#4913); +#4913 = DEFINITIONAL_REPRESENTATION('',(#4914),#4918); +#4914 = LINE('',#4915,#4916); +#4915 = CARTESIAN_POINT('',(-0.785398163398,-7.105427357601E-15)); +#4916 = VECTOR('',#4917,1.); +#4917 = DIRECTION('',(1.03880516924E-16,1.)); +#4918 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4919 = PCURVE('',#3621,#4920); +#4920 = DEFINITIONAL_REPRESENTATION('',(#4921),#4925); +#4921 = LINE('',#4922,#4923); +#4922 = CARTESIAN_POINT('',(25.150000000011,-8.5)); +#4923 = VECTOR('',#4924,1.); +#4924 = DIRECTION('',(-7.861397491567E-28,-1.)); +#4925 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4926 = ORIENTED_EDGE('',*,*,#4927,.F.); +#4927 = EDGE_CURVE('',#4723,#4905,#4928,.T.); +#4928 = SURFACE_CURVE('',#4929,(#4934,#4963),.PCURVE_S1.); +#4929 = ELLIPSE('',#4930,1.414213562373,1.); +#4930 = AXIS2_PLACEMENT_3D('',#4931,#4932,#4933); +#4931 = CARTESIAN_POINT('',(-23.99999999994,-36.6,30.150000000001)); +#4932 = DIRECTION('',(0.707106781187,5.623574421305E-13,0.707106781187) + ); +#4933 = DIRECTION('',(0.707106781187,5.609270660378E-13,-0.707106781187) + ); +#4934 = PCURVE('',#3593,#4935); +#4935 = DEFINITIONAL_REPRESENTATION('',(#4936),#4962); +#4936 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#4937,#4938,#4939,#4940,#4941, + #4942,#4943,#4944,#4945,#4946,#4947,#4948,#4949,#4950,#4951,#4952, + #4953,#4954,#4955,#4956,#4957,#4958,#4959,#4960,#4961), + .UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4), + (0.,7.139983303613E-02,0.142799666072,0.214199499108,0.285599332145, + 0.356999165181,0.428398998217,0.499798831253,0.571198664289, + 0.642598497325,0.713998330361,0.785398163397,0.856797996434, + 0.92819782947,0.999597662506,1.070997495542,1.142397328578, + 1.213797161614,1.28519699465,1.356596827687,1.427996660723, + 1.499396493759,1.570796326795),.QUASI_UNIFORM_KNOTS.); +#4937 = CARTESIAN_POINT('',(0.785398163397,-16.15)); +#4938 = CARTESIAN_POINT('',(0.761598219052,-16.14999784344)); +#4939 = CARTESIAN_POINT('',(0.713998330361,-16.15170103495)); +#4940 = CARTESIAN_POINT('',(0.642598497325,-16.15933692484)); +#4941 = CARTESIAN_POINT('',(0.571198664289,-16.17202261439)); +#4942 = CARTESIAN_POINT('',(0.499798831252,-16.18969142175)); +#4943 = CARTESIAN_POINT('',(0.428398998216,-16.21225385692)); +#4944 = CARTESIAN_POINT('',(0.35699916518,-16.23959480056)); +#4945 = CARTESIAN_POINT('',(0.285599332144,-16.2715749687)); +#4946 = CARTESIAN_POINT('',(0.214199499108,-16.30803138722)); +#4947 = CARTESIAN_POINT('',(0.142799666072,-16.3487782854)); +#4948 = CARTESIAN_POINT('',(7.139983303567E-02,-16.39360802561)); +#4949 = CARTESIAN_POINT('',(-4.449773882698E-13,-16.442292166)); +#4950 = CARTESIAN_POINT('',(-7.139983303658E-02,-16.49458262326)); +#4951 = CARTESIAN_POINT('',(-0.142799666073,-16.55021293726)); +#4952 = CARTESIAN_POINT('',(-0.214199499109,-16.60889962862)); +#4953 = CARTESIAN_POINT('',(-0.285599332145,-16.6703436435)); +#4954 = CARTESIAN_POINT('',(-0.356999165181,-16.73423187703)); +#4955 = CARTESIAN_POINT('',(-0.428398998217,-16.80023877034)); +#4956 = CARTESIAN_POINT('',(-0.499798831253,-16.868027964)); +#4957 = CARTESIAN_POINT('',(-0.571198664289,-16.93725403261)); +#4958 = CARTESIAN_POINT('',(-0.642598497326,-17.00756416822)); +#4959 = CARTESIAN_POINT('',(-0.713998330362,-17.07860026483)); +#4960 = CARTESIAN_POINT('',(-0.761598219052,-17.12619987043)); +#4961 = CARTESIAN_POINT('',(-0.785398163398,-17.15)); +#4962 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4963 = PCURVE('',#4738,#4964); +#4964 = DEFINITIONAL_REPRESENTATION('',(#4965),#4969); +#4965 = ELLIPSE('',#4966,1.414213562373,1.); +#4966 = AXIS2_PLACEMENT_2D('',#4967,#4968); +#4967 = CARTESIAN_POINT('',(1.414213562374,6.3)); +#4968 = DIRECTION('',(-1.,-4.097242122712E-16)); +#4969 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4970 = ADVANCED_FACE('',(#4971,#5080,#5115,#5150),#3621,.T.); +#4971 = FACE_BOUND('',#4972,.T.); +#4972 = EDGE_LOOP('',(#4973,#4974,#4997,#5030,#5058,#5079)); +#4973 = ORIENTED_EDGE('',*,*,#4904,.F.); +#4974 = ORIENTED_EDGE('',*,*,#4975,.T.); +#4975 = EDGE_CURVE('',#4905,#4976,#4978,.T.); +#4976 = VERTEX_POINT('',#4977); +#4977 = CARTESIAN_POINT('',(-31.17842712469,-35.6,37.328427124746)); +#4978 = SURFACE_CURVE('',#4979,(#4983,#4990),.PCURVE_S1.); +#4979 = LINE('',#4980,#4981); +#4980 = CARTESIAN_POINT('',(-22.99999999994,-35.59999999999,29.15)); +#4981 = VECTOR('',#4982,1.); +#4982 = DIRECTION('',(-0.707106781187,-5.605173418255E-13,0.707106781187 + )); +#4983 = PCURVE('',#3621,#4984); +#4984 = DEFINITIONAL_REPRESENTATION('',(#4985),#4989); +#4985 = LINE('',#4986,#4987); +#4986 = CARTESIAN_POINT('',(26.150000000012,7.65)); +#4987 = VECTOR('',#4988,1.); +#4988 = DIRECTION('',(-0.707106781187,0.707106781187)); +#4989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4990 = PCURVE('',#4738,#4991); +#4991 = DEFINITIONAL_REPRESENTATION('',(#4992),#4996); +#4992 = LINE('',#4993,#4994); +#4993 = CARTESIAN_POINT('',(6.407349680401E-15,5.3)); +#4994 = VECTOR('',#4995,1.); +#4995 = DIRECTION('',(1.,-1.007095080516E-28)); +#4996 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#4997 = ORIENTED_EDGE('',*,*,#4998,.F.); +#4998 = EDGE_CURVE('',#4999,#4976,#5001,.T.); +#4999 = VERTEX_POINT('',#5000); +#5000 = CARTESIAN_POINT('',(-34.00685424944,-35.6,38.5)); +#5001 = SURFACE_CURVE('',#5002,(#5007,#5018),.PCURVE_S1.); +#5002 = CIRCLE('',#5003,4.); +#5003 = AXIS2_PLACEMENT_3D('',#5004,#5005,#5006); +#5004 = CARTESIAN_POINT('',(-34.00685424944,-35.6,34.5)); +#5005 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#5006 = DIRECTION('',(0.382683432365,3.048037551954E-13,0.923879532511) + ); +#5007 = PCURVE('',#3621,#5008); +#5008 = DEFINITIONAL_REPRESENTATION('',(#5009),#5017); +#5009 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5010,#5011,#5012,#5013, +#5014,#5015,#5016),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5010 = CARTESIAN_POINT('',(16.67387947998,16.695518130045)); +#5011 = CARTESIAN_POINT('',(23.07470464151,14.04420953776)); +#5012 = CARTESIAN_POINT('',(17.578191466555,9.826586638835)); +#5013 = CARTESIAN_POINT('',(12.081678291599,5.60896373991)); +#5014 = CARTESIAN_POINT('',(11.177366305025,12.47789523112)); +#5015 = CARTESIAN_POINT('',(10.27305431845,19.34682672233)); +#5016 = CARTESIAN_POINT('',(16.67387947998,16.695518130045)); +#5017 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5018 = PCURVE('',#5019,#5024); +#5019 = CYLINDRICAL_SURFACE('',#5020,4.); +#5020 = AXIS2_PLACEMENT_3D('',#5021,#5022,#5023); +#5021 = CARTESIAN_POINT('',(-34.00685424944,-30.3,34.5)); +#5022 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#5023 = DIRECTION('',(0.382683432365,3.053188729141E-13,0.923879532511) + ); +#5024 = DEFINITIONAL_REPRESENTATION('',(#5025),#5029); +#5025 = LINE('',#5026,#5027); +#5026 = CARTESIAN_POINT('',(6.28318530718,5.3)); +#5027 = VECTOR('',#5028,1.); +#5028 = DIRECTION('',(-1.,9.04691109394E-15)); +#5029 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5030 = ORIENTED_EDGE('',*,*,#5031,.T.); +#5031 = EDGE_CURVE('',#4999,#5032,#5034,.T.); +#5032 = VERTEX_POINT('',#5033); +#5033 = CARTESIAN_POINT('',(-75.29999999997,-35.60000000004,38.5)); +#5034 = SURFACE_CURVE('',#5035,(#5039,#5046),.PCURVE_S1.); +#5035 = LINE('',#5036,#5037); +#5036 = CARTESIAN_POINT('',(-75.29999999997,-35.60000000004,38.5)); +#5037 = VECTOR('',#5038,1.); +#5038 = DIRECTION('',(-1.,-7.938040362974E-13,-1.018942737705E-15)); +#5039 = PCURVE('',#3621,#5040); +#5040 = DEFINITIONAL_REPRESENTATION('',(#5041),#5045); +#5041 = LINE('',#5042,#5043); +#5042 = CARTESIAN_POINT('',(-26.15000000001,17.)); +#5043 = VECTOR('',#5044,1.); +#5044 = DIRECTION('',(-1.,-1.018942737705E-15)); +#5045 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5046 = PCURVE('',#5047,#5052); +#5047 = PLANE('',#5048); +#5048 = AXIS2_PLACEMENT_3D('',#5049,#5050,#5051); +#5049 = CARTESIAN_POINT('',(-32.34999999995,-30.3,38.5)); +#5050 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#5051 = DIRECTION('',(-1.,-7.938040362974E-13,-1.018942737705E-15)); +#5052 = DEFINITIONAL_REPRESENTATION('',(#5053),#5057); +#5053 = LINE('',#5054,#5055); +#5054 = CARTESIAN_POINT('',(42.950000000024,5.3)); +#5055 = VECTOR('',#5056,1.); +#5056 = DIRECTION('',(1.,9.91418586352E-29)); +#5057 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5058 = ORIENTED_EDGE('',*,*,#5059,.T.); +#5059 = EDGE_CURVE('',#5032,#3606,#5060,.T.); +#5060 = SURFACE_CURVE('',#5061,(#5065,#5072),.PCURVE_S1.); +#5061 = LINE('',#5062,#5063); +#5062 = CARTESIAN_POINT('',(-75.29999999997,-35.60000000004,4.5)); +#5063 = VECTOR('',#5064,1.); +#5064 = DIRECTION('',(7.199750894054E-28,-1.112809542387E-15,-1.)); +#5065 = PCURVE('',#3621,#5066); +#5066 = DEFINITIONAL_REPRESENTATION('',(#5067),#5071); +#5067 = LINE('',#5068,#5069); +#5068 = CARTESIAN_POINT('',(-26.15000000001,-17.)); +#5069 = VECTOR('',#5070,1.); +#5070 = DIRECTION('',(1.793662034336E-43,-1.)); +#5071 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5072 = PCURVE('',#3649,#5073); +#5073 = DEFINITIONAL_REPRESENTATION('',(#5074),#5078); +#5074 = LINE('',#5075,#5076); +#5075 = CARTESIAN_POINT('',(34.,5.3)); +#5076 = VECTOR('',#5077,1.); +#5077 = DIRECTION('',(1.,0.)); +#5078 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5079 = ORIENTED_EDGE('',*,*,#3605,.T.); +#5080 = FACE_BOUND('',#5081,.T.); +#5081 = EDGE_LOOP('',(#5082)); +#5082 = ORIENTED_EDGE('',*,*,#5083,.T.); +#5083 = EDGE_CURVE('',#5084,#5084,#5086,.T.); +#5084 = VERTEX_POINT('',#5085); +#5085 = CARTESIAN_POINT('',(-38.99999999995,-35.60000000001,7.)); +#5086 = SURFACE_CURVE('',#5087,(#5092,#5103),.PCURVE_S1.); +#5087 = CIRCLE('',#5088,2.); +#5088 = AXIS2_PLACEMENT_3D('',#5089,#5090,#5091); +#5089 = CARTESIAN_POINT('',(-36.99999999995,-35.60000000001,7.)); +#5090 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#5091 = DIRECTION('',(1.,7.938040362974E-13,-1.633950156862E-28)); +#5092 = PCURVE('',#3621,#5093); +#5093 = DEFINITIONAL_REPRESENTATION('',(#5094),#5102); +#5094 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5095,#5096,#5097,#5098, +#5099,#5100,#5101),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5095 = CARTESIAN_POINT('',(14.150000000009,-14.5)); +#5096 = CARTESIAN_POINT('',(14.150000000009,-17.96410161513)); +#5097 = CARTESIAN_POINT('',(11.150000000009,-16.23205080756)); +#5098 = CARTESIAN_POINT('',(8.150000000009,-14.5)); +#5099 = CARTESIAN_POINT('',(11.150000000009,-12.76794919243)); +#5100 = CARTESIAN_POINT('',(14.150000000009,-11.03589838486)); +#5101 = CARTESIAN_POINT('',(14.150000000009,-14.5)); +#5102 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5103 = PCURVE('',#5104,#5109); +#5104 = CYLINDRICAL_SURFACE('',#5105,2.); +#5105 = AXIS2_PLACEMENT_3D('',#5106,#5107,#5108); +#5106 = CARTESIAN_POINT('',(-36.99999999995,-35.60000000001,7.)); +#5107 = DIRECTION('',(-7.93809462607E-13,1.,-1.224646799147E-16)); +#5108 = DIRECTION('',(1.,7.93809462607E-13,-1.634010541353E-28)); +#5109 = DEFINITIONAL_REPRESENTATION('',(#5110),#5114); +#5110 = LINE('',#5111,#5112); +#5111 = CARTESIAN_POINT('',(0.,0.)); +#5112 = VECTOR('',#5113,1.); +#5113 = DIRECTION('',(1.,0.)); +#5114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5115 = FACE_BOUND('',#5116,.T.); +#5116 = EDGE_LOOP('',(#5117)); +#5117 = ORIENTED_EDGE('',*,*,#5118,.T.); +#5118 = EDGE_CURVE('',#5119,#5119,#5121,.T.); +#5119 = VERTEX_POINT('',#5120); +#5120 = CARTESIAN_POINT('',(-74.79999999997,-35.60000000004,7.)); +#5121 = SURFACE_CURVE('',#5122,(#5127,#5138),.PCURVE_S1.); +#5122 = CIRCLE('',#5123,2.); +#5123 = AXIS2_PLACEMENT_3D('',#5124,#5125,#5126); +#5124 = CARTESIAN_POINT('',(-72.79999999997,-35.60000000003,7.)); +#5125 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#5126 = DIRECTION('',(1.,7.938040362974E-13,-1.643494608017E-28)); +#5127 = PCURVE('',#3621,#5128); +#5128 = DEFINITIONAL_REPRESENTATION('',(#5129),#5137); +#5129 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5130,#5131,#5132,#5133, +#5134,#5135,#5136),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5130 = CARTESIAN_POINT('',(-21.65000000001,-14.5)); +#5131 = CARTESIAN_POINT('',(-21.65000000001,-17.96410161513)); +#5132 = CARTESIAN_POINT('',(-24.65000000001,-16.23205080756)); +#5133 = CARTESIAN_POINT('',(-27.65000000001,-14.5)); +#5134 = CARTESIAN_POINT('',(-24.65000000001,-12.76794919243)); +#5135 = CARTESIAN_POINT('',(-21.65000000001,-11.03589838486)); +#5136 = CARTESIAN_POINT('',(-21.65000000001,-14.5)); +#5137 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5138 = PCURVE('',#5139,#5144); +#5139 = CYLINDRICAL_SURFACE('',#5140,2.); +#5140 = AXIS2_PLACEMENT_3D('',#5141,#5142,#5143); +#5141 = CARTESIAN_POINT('',(-72.79999999997,-35.60000000003,7.)); +#5142 = DIRECTION('',(-7.926992395824E-13,1.,-1.224646799147E-16)); +#5143 = DIRECTION('',(1.,7.926992395824E-13,-1.631200324748E-28)); +#5144 = DEFINITIONAL_REPRESENTATION('',(#5145),#5149); +#5145 = LINE('',#5146,#5147); +#5146 = CARTESIAN_POINT('',(0.,0.)); +#5147 = VECTOR('',#5148,1.); +#5148 = DIRECTION('',(1.,0.)); +#5149 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5150 = FACE_BOUND('',#5151,.T.); +#5151 = EDGE_LOOP('',(#5152)); +#5152 = ORIENTED_EDGE('',*,*,#5153,.T.); +#5153 = EDGE_CURVE('',#5154,#5154,#5156,.T.); +#5154 = VERTEX_POINT('',#5155); +#5155 = CARTESIAN_POINT('',(-74.79999999997,-35.60000000004,36.)); +#5156 = SURFACE_CURVE('',#5157,(#5162,#5173),.PCURVE_S1.); +#5157 = CIRCLE('',#5158,2.); +#5158 = AXIS2_PLACEMENT_3D('',#5159,#5160,#5161); +#5159 = CARTESIAN_POINT('',(-72.79999999997,-35.60000000003,36.)); +#5160 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#5161 = DIRECTION('',(1.,7.938040362974E-13,-1.643494608017E-28)); +#5162 = PCURVE('',#3621,#5163); +#5163 = DEFINITIONAL_REPRESENTATION('',(#5164),#5172); +#5164 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5165,#5166,#5167,#5168, +#5169,#5170,#5171),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5165 = CARTESIAN_POINT('',(-21.65000000001,14.5)); +#5166 = CARTESIAN_POINT('',(-21.65000000001,11.035898384862)); +#5167 = CARTESIAN_POINT('',(-24.65000000001,12.767949192431)); +#5168 = CARTESIAN_POINT('',(-27.65000000001,14.5)); +#5169 = CARTESIAN_POINT('',(-24.65000000001,16.232050807569)); +#5170 = CARTESIAN_POINT('',(-21.65000000001,17.964101615138)); +#5171 = CARTESIAN_POINT('',(-21.65000000001,14.5)); +#5172 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5173 = PCURVE('',#5174,#5179); +#5174 = CYLINDRICAL_SURFACE('',#5175,2.); +#5175 = AXIS2_PLACEMENT_3D('',#5176,#5177,#5178); +#5176 = CARTESIAN_POINT('',(-72.79999999997,-35.60000000003,36.)); +#5177 = DIRECTION('',(-7.926992395824E-13,1.,-1.224646799147E-16)); +#5178 = DIRECTION('',(1.,7.926992395824E-13,-1.631200324748E-28)); +#5179 = DEFINITIONAL_REPRESENTATION('',(#5180),#5184); +#5180 = LINE('',#5181,#5182); +#5181 = CARTESIAN_POINT('',(0.,0.)); +#5182 = VECTOR('',#5183,1.); +#5183 = DIRECTION('',(1.,0.)); +#5184 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5185 = ADVANCED_FACE('',(#5186),#3537,.F.); +#5186 = FACE_BOUND('',#5187,.F.); +#5187 = EDGE_LOOP('',(#5188,#5189,#5217,#5238)); +#5188 = ORIENTED_EDGE('',*,*,#4772,.F.); +#5189 = ORIENTED_EDGE('',*,*,#5190,.F.); +#5190 = EDGE_CURVE('',#5191,#4773,#5193,.T.); +#5191 = VERTEX_POINT('',#5192); +#5192 = CARTESIAN_POINT('',(-23.99999999994,-38.59999999999,38.5)); +#5193 = SURFACE_CURVE('',#5194,(#5199,#5206),.PCURVE_S1.); +#5194 = CIRCLE('',#5195,1.); +#5195 = AXIS2_PLACEMENT_3D('',#5196,#5197,#5198); +#5196 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999,38.5)); +#5197 = DIRECTION('',(-1.146036670579E-15,1.833155447163E-15,1.)); +#5198 = DIRECTION('',(0.707106781187,-0.707106781187,2.106606948913E-15) + ); +#5199 = PCURVE('',#3537,#5200); +#5200 = DEFINITIONAL_REPRESENTATION('',(#5201),#5205); +#5201 = LINE('',#5202,#5203); +#5202 = CARTESIAN_POINT('',(-3.552713678801E-15,34.)); +#5203 = VECTOR('',#5204,1.); +#5204 = DIRECTION('',(1.,0.)); +#5205 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5206 = PCURVE('',#4811,#5207); +#5207 = DEFINITIONAL_REPRESENTATION('',(#5208),#5216); +#5208 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5209,#5210,#5211,#5212, +#5213,#5214,#5215),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5209 = CARTESIAN_POINT('',(52.29289321873,26.292893218852)); +#5210 = CARTESIAN_POINT('',(51.068148347341,27.517638090246)); +#5211 = CARTESIAN_POINT('',(52.741180954817,27.965925826327)); +#5212 = CARTESIAN_POINT('',(54.414213562293,28.414213562409)); +#5213 = CARTESIAN_POINT('',(53.965925826207,26.741180954934)); +#5214 = CARTESIAN_POINT('',(53.51763809012,25.068148347459)); +#5215 = CARTESIAN_POINT('',(52.29289321873,26.292893218852)); +#5216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5217 = ORIENTED_EDGE('',*,*,#5218,.F.); +#5218 = EDGE_CURVE('',#3489,#5191,#5219,.T.); +#5219 = SURFACE_CURVE('',#5220,(#5224,#5231),.PCURVE_S1.); +#5220 = LINE('',#5221,#5222); +#5221 = CARTESIAN_POINT('',(-23.99999999994,-38.59999999999,4.5)); +#5222 = VECTOR('',#5223,1.); +#5223 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#5224 = PCURVE('',#3537,#5225); +#5225 = DEFINITIONAL_REPRESENTATION('',(#5226),#5230); +#5226 = LINE('',#5227,#5228); +#5227 = CARTESIAN_POINT('',(5.497787143782,0.)); +#5228 = VECTOR('',#5229,1.); +#5229 = DIRECTION('',(0.,1.)); +#5230 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5231 = PCURVE('',#3504,#5232); +#5232 = DEFINITIONAL_REPRESENTATION('',(#5233),#5237); +#5233 = LINE('',#5234,#5235); +#5234 = CARTESIAN_POINT('',(1.,-1.331994833898E-28)); +#5235 = VECTOR('',#5236,1.); +#5236 = DIRECTION('',(0.,1.)); +#5237 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5238 = ORIENTED_EDGE('',*,*,#3516,.F.); +#5239 = ADVANCED_FACE('',(#5240),#3504,.T.); +#5240 = FACE_BOUND('',#5241,.T.); +#5241 = EDGE_LOOP('',(#5242,#5243,#5244,#5267)); +#5242 = ORIENTED_EDGE('',*,*,#5218,.F.); +#5243 = ORIENTED_EDGE('',*,*,#3488,.T.); +#5244 = ORIENTED_EDGE('',*,*,#5245,.F.); +#5245 = EDGE_CURVE('',#5246,#3460,#5248,.T.); +#5246 = VERTEX_POINT('',#5247); +#5247 = CARTESIAN_POINT('',(-30.00000000006,-38.59999999999,38.5)); +#5248 = SURFACE_CURVE('',#5249,(#5253,#5260),.PCURVE_S1.); +#5249 = LINE('',#5250,#5251); +#5250 = CARTESIAN_POINT('',(-30.00000000006,-38.59999999999,21.5)); +#5251 = VECTOR('',#5252,1.); +#5252 = DIRECTION('',(1.16838698865E-27,-1.224646799147E-16,-1.)); +#5253 = PCURVE('',#3504,#5254); +#5254 = DEFINITIONAL_REPRESENTATION('',(#5255),#5259); +#5255 = LINE('',#5256,#5257); +#5256 = CARTESIAN_POINT('',(7.000000000115,17.)); +#5257 = VECTOR('',#5258,1.); +#5258 = DIRECTION('',(-1.234551648401E-27,-1.)); +#5259 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5260 = PCURVE('',#3476,#5261); +#5261 = DEFINITIONAL_REPRESENTATION('',(#5262),#5266); +#5262 = LINE('',#5263,#5264); +#5263 = CARTESIAN_POINT('',(5.497787143783,0.)); +#5264 = VECTOR('',#5265,1.); +#5265 = DIRECTION('',(0.,-1.)); +#5266 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5267 = ORIENTED_EDGE('',*,*,#5268,.T.); +#5268 = EDGE_CURVE('',#5246,#5191,#5269,.T.); +#5269 = SURFACE_CURVE('',#5270,(#5274,#5281),.PCURVE_S1.); +#5270 = LINE('',#5271,#5272); +#5271 = CARTESIAN_POINT('',(-12.49999999996,-38.59999999999,38.5)); +#5272 = VECTOR('',#5273,1.); +#5273 = DIRECTION('',(1.,9.325873406851E-15,1.018942737706E-15)); +#5274 = PCURVE('',#3504,#5275); +#5275 = DEFINITIONAL_REPRESENTATION('',(#5276),#5280); +#5276 = LINE('',#5277,#5278); +#5277 = CARTESIAN_POINT('',(-10.49999999997,34.)); +#5278 = VECTOR('',#5279,1.); +#5279 = DIRECTION('',(-1.,1.018942737707E-15)); +#5280 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5281 = PCURVE('',#4811,#5282); +#5282 = DEFINITIONAL_REPRESENTATION('',(#5283),#5287); +#5283 = LINE('',#5284,#5285); +#5284 = CARTESIAN_POINT('',(41.499999999937,26.000000000055)); +#5285 = VECTOR('',#5286,1.); +#5286 = DIRECTION('',(-1.,1.44839071177E-12)); +#5287 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5288 = ADVANCED_FACE('',(#5289),#2899,.T.); +#5289 = FACE_BOUND('',#5290,.T.); +#5290 = EDGE_LOOP('',(#5291,#5292,#5315,#5339)); +#5291 = ORIENTED_EDGE('',*,*,#2882,.T.); +#5292 = ORIENTED_EDGE('',*,*,#5293,.T.); +#5293 = EDGE_CURVE('',#2855,#5294,#5296,.T.); +#5294 = VERTEX_POINT('',#5295); +#5295 = CARTESIAN_POINT('',(-23.99999999994,40.599999999996,36.5)); +#5296 = SURFACE_CURVE('',#5297,(#5301,#5308),.PCURVE_S1.); +#5297 = LINE('',#5298,#5299); +#5298 = CARTESIAN_POINT('',(-23.99999999994,40.599999999996,4.5)); +#5299 = VECTOR('',#5300,1.); +#5300 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#5301 = PCURVE('',#2899,#5302); +#5302 = DEFINITIONAL_REPRESENTATION('',(#5303),#5307); +#5303 = LINE('',#5304,#5305); +#5304 = CARTESIAN_POINT('',(7.068583470577,0.)); +#5305 = VECTOR('',#5306,1.); +#5306 = DIRECTION('',(0.,1.)); +#5307 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5308 = PCURVE('',#2870,#5309); +#5309 = DEFINITIONAL_REPRESENTATION('',(#5310),#5314); +#5310 = LINE('',#5311,#5312); +#5311 = CARTESIAN_POINT('',(9.000000000056,1.19444453108E-27)); +#5312 = VECTOR('',#5313,1.); +#5313 = DIRECTION('',(0.,1.)); +#5314 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5315 = ORIENTED_EDGE('',*,*,#5316,.F.); +#5316 = EDGE_CURVE('',#5317,#5294,#5319,.T.); +#5317 = VERTEX_POINT('',#5318); +#5318 = CARTESIAN_POINT('',(-20.99999999994,37.599999999996,36.5)); +#5319 = SURFACE_CURVE('',#5320,(#5325,#5332),.PCURVE_S1.); +#5320 = CIRCLE('',#5321,3.); +#5321 = AXIS2_PLACEMENT_3D('',#5322,#5323,#5324); +#5322 = CARTESIAN_POINT('',(-23.99999999994,37.599999999996,36.5)); +#5323 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#5324 = DIRECTION('',(0.707106781187,0.707106781187,-5.51069726666E-16) + ); +#5325 = PCURVE('',#2899,#5326); +#5326 = DEFINITIONAL_REPRESENTATION('',(#5327),#5331); +#5327 = LINE('',#5328,#5329); +#5328 = CARTESIAN_POINT('',(0.,32.)); +#5329 = VECTOR('',#5330,1.); +#5330 = DIRECTION('',(1.,-4.52345554697E-15)); +#5331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5332 = PCURVE('',#2685,#5333); +#5333 = DEFINITIONAL_REPRESENTATION('',(#5334),#5338); +#5334 = CIRCLE('',#5335,3.); +#5335 = AXIS2_PLACEMENT_2D('',#5336,#5337); +#5336 = CARTESIAN_POINT('',(-21.99999999995,37.599999999997)); +#5337 = DIRECTION('',(0.707106781187,0.707106781187)); +#5338 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5339 = ORIENTED_EDGE('',*,*,#5340,.T.); +#5340 = EDGE_CURVE('',#5317,#2883,#5341,.T.); +#5341 = SURFACE_CURVE('',#5342,(#5346,#5353),.PCURVE_S1.); +#5342 = LINE('',#5343,#5344); +#5343 = CARTESIAN_POINT('',(-20.99999999994,37.599999999996,4.5)); +#5344 = VECTOR('',#5345,1.); +#5345 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#5346 = PCURVE('',#2899,#5347); +#5347 = DEFINITIONAL_REPRESENTATION('',(#5348),#5352); +#5348 = LINE('',#5349,#5350); +#5349 = CARTESIAN_POINT('',(5.497787143782,0.)); +#5350 = VECTOR('',#5351,1.); +#5351 = DIRECTION('',(0.,-1.)); +#5352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5353 = PCURVE('',#2927,#5354); +#5354 = DEFINITIONAL_REPRESENTATION('',(#5355),#5359); +#5355 = LINE('',#5356,#5357); +#5356 = CARTESIAN_POINT('',(1.,-1.224646799147E-16)); +#5357 = VECTOR('',#5358,1.); +#5358 = DIRECTION('',(0.,-1.)); +#5359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5360 = ADVANCED_FACE('',(#5361),#2927,.F.); +#5361 = FACE_BOUND('',#5362,.T.); +#5362 = EDGE_LOOP('',(#5363,#5364,#5387,#5408,#5409,#5432,#5455,#5476)); +#5363 = ORIENTED_EDGE('',*,*,#5340,.F.); +#5364 = ORIENTED_EDGE('',*,*,#5365,.F.); +#5365 = EDGE_CURVE('',#5366,#5317,#5368,.T.); +#5366 = VERTEX_POINT('',#5367); +#5367 = CARTESIAN_POINT('',(-20.99999999994,-37.59999999999,36.5)); +#5368 = SURFACE_CURVE('',#5369,(#5373,#5380),.PCURVE_S1.); +#5369 = LINE('',#5370,#5371); +#5370 = CARTESIAN_POINT('',(-20.99999999994,19.299999999997,36.5)); +#5371 = VECTOR('',#5372,1.); +#5372 = DIRECTION('',(-1.108792885622E-43,1.,-1.798273018971E-15)); +#5373 = PCURVE('',#2927,#5374); +#5374 = DEFINITIONAL_REPRESENTATION('',(#5375),#5379); +#5375 = LINE('',#5376,#5377); +#5376 = CARTESIAN_POINT('',(19.299999999999,32.)); +#5377 = VECTOR('',#5378,1.); +#5378 = DIRECTION('',(-1.,-1.675808339056E-15)); +#5379 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5380 = PCURVE('',#2685,#5381); +#5381 = DEFINITIONAL_REPRESENTATION('',(#5382),#5386); +#5382 = LINE('',#5383,#5384); +#5383 = CARTESIAN_POINT('',(-18.99999999995,19.299999999999)); +#5384 = VECTOR('',#5385,1.); +#5385 = DIRECTION('',(-1.707552736869E-30,1.)); +#5386 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5387 = ORIENTED_EDGE('',*,*,#5388,.F.); +#5388 = EDGE_CURVE('',#3719,#5366,#5389,.T.); +#5389 = SURFACE_CURVE('',#5390,(#5394,#5401),.PCURVE_S1.); +#5390 = LINE('',#5391,#5392); +#5391 = CARTESIAN_POINT('',(-20.99999999994,-37.59999999999,4.5)); +#5392 = VECTOR('',#5393,1.); +#5393 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#5394 = PCURVE('',#2927,#5395); +#5395 = DEFINITIONAL_REPRESENTATION('',(#5396),#5400); +#5396 = LINE('',#5397,#5398); +#5397 = CARTESIAN_POINT('',(76.199999999995,-9.331808609502E-15)); +#5398 = VECTOR('',#5399,1.); +#5399 = DIRECTION('',(0.,1.)); +#5400 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5401 = PCURVE('',#3758,#5402); +#5402 = DEFINITIONAL_REPRESENTATION('',(#5403),#5407); +#5403 = LINE('',#5404,#5405); +#5404 = CARTESIAN_POINT('',(7.068583470577,0.)); +#5405 = VECTOR('',#5406,1.); +#5406 = DIRECTION('',(0.,1.)); +#5407 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5408 = ORIENTED_EDGE('',*,*,#3718,.F.); +#5409 = ORIENTED_EDGE('',*,*,#5410,.F.); +#5410 = EDGE_CURVE('',#5411,#3690,#5413,.T.); +#5411 = VERTEX_POINT('',#5412); +#5412 = CARTESIAN_POINT('',(-20.99999999994,-34.59999999999,33.5)); +#5413 = SURFACE_CURVE('',#5414,(#5418,#5425),.PCURVE_S1.); +#5414 = LINE('',#5415,#5416); +#5415 = CARTESIAN_POINT('',(-20.99999999994,-34.59999999999,4.5)); +#5416 = VECTOR('',#5417,1.); +#5417 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#5418 = PCURVE('',#2927,#5419); +#5419 = DEFINITIONAL_REPRESENTATION('',(#5420),#5424); +#5420 = LINE('',#5421,#5422); +#5421 = CARTESIAN_POINT('',(73.199999999995,-8.964414569758E-15)); +#5422 = VECTOR('',#5423,1.); +#5423 = DIRECTION('',(0.,-1.)); +#5424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5425 = PCURVE('',#3706,#5426); +#5426 = DEFINITIONAL_REPRESENTATION('',(#5427),#5431); +#5427 = LINE('',#5428,#5429); +#5428 = CARTESIAN_POINT('',(5.497787143782,0.)); +#5429 = VECTOR('',#5430,1.); +#5430 = DIRECTION('',(0.,-1.)); +#5431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5432 = ORIENTED_EDGE('',*,*,#5433,.F.); +#5433 = EDGE_CURVE('',#5434,#5411,#5436,.T.); +#5434 = VERTEX_POINT('',#5435); +#5435 = CARTESIAN_POINT('',(-20.99999999994,34.600000000031,33.5)); +#5436 = SURFACE_CURVE('',#5437,(#5441,#5448),.PCURVE_S1.); +#5437 = LINE('',#5438,#5439); +#5438 = CARTESIAN_POINT('',(-20.99999999994,34.600000000014,33.5)); +#5439 = VECTOR('',#5440,1.); +#5440 = DIRECTION('',(-4.45098715844E-61,-1.,1.224646799147E-16)); +#5441 = PCURVE('',#2927,#5442); +#5442 = DEFINITIONAL_REPRESENTATION('',(#5443),#5447); +#5443 = LINE('',#5444,#5445); +#5444 = CARTESIAN_POINT('',(3.999999999982,29.)); +#5445 = VECTOR('',#5446,1.); +#5446 = DIRECTION('',(1.,0.)); +#5447 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5448 = PCURVE('',#4687,#5449); +#5449 = DEFINITIONAL_REPRESENTATION('',(#5450),#5454); +#5450 = LINE('',#5451,#5452); +#5451 = CARTESIAN_POINT('',(-3.999999999982,2.)); +#5452 = VECTOR('',#5453,1.); +#5453 = DIRECTION('',(1.,2.228967694695E-42)); +#5454 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5455 = ORIENTED_EDGE('',*,*,#5456,.F.); +#5456 = EDGE_CURVE('',#2912,#5434,#5457,.T.); +#5457 = SURFACE_CURVE('',#5458,(#5462,#5469),.PCURVE_S1.); +#5458 = LINE('',#5459,#5460); +#5459 = CARTESIAN_POINT('',(-20.99999999994,34.600000000031,4.5)); +#5460 = VECTOR('',#5461,1.); +#5461 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#5462 = PCURVE('',#2927,#5463); +#5463 = DEFINITIONAL_REPRESENTATION('',(#5464),#5468); +#5464 = LINE('',#5465,#5466); +#5465 = CARTESIAN_POINT('',(3.999999999965,-4.898587196546E-16)); +#5466 = VECTOR('',#5467,1.); +#5467 = DIRECTION('',(0.,1.)); +#5468 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5469 = PCURVE('',#2956,#5470); +#5470 = DEFINITIONAL_REPRESENTATION('',(#5471),#5475); +#5471 = LINE('',#5472,#5473); +#5472 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#5473 = VECTOR('',#5474,1.); +#5474 = DIRECTION('',(0.,-1.)); +#5475 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5476 = ORIENTED_EDGE('',*,*,#2911,.F.); +#5477 = ADVANCED_FACE('',(#5478),#3758,.T.); +#5478 = FACE_BOUND('',#5479,.T.); +#5479 = EDGE_LOOP('',(#5480,#5481,#5482,#5506)); +#5480 = ORIENTED_EDGE('',*,*,#3741,.T.); +#5481 = ORIENTED_EDGE('',*,*,#5388,.T.); +#5482 = ORIENTED_EDGE('',*,*,#5483,.F.); +#5483 = EDGE_CURVE('',#5484,#5366,#5486,.T.); +#5484 = VERTEX_POINT('',#5485); +#5485 = CARTESIAN_POINT('',(-23.99999999994,-40.59999999999,36.5)); +#5486 = SURFACE_CURVE('',#5487,(#5492,#5499),.PCURVE_S1.); +#5487 = CIRCLE('',#5488,3.); +#5488 = AXIS2_PLACEMENT_3D('',#5489,#5490,#5491); +#5489 = CARTESIAN_POINT('',(-23.99999999994,-37.59999999999,36.5)); +#5490 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#5491 = DIRECTION('',(0.707106781187,-0.707106781187,1.992072365612E-15) + ); +#5492 = PCURVE('',#3758,#5493); +#5493 = DEFINITIONAL_REPRESENTATION('',(#5494),#5498); +#5494 = LINE('',#5495,#5496); +#5495 = CARTESIAN_POINT('',(-2.6645352591E-15,32.)); +#5496 = VECTOR('',#5497,1.); +#5497 = DIRECTION('',(1.,-4.52345554697E-15)); +#5498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5499 = PCURVE('',#2685,#5500); +#5500 = DEFINITIONAL_REPRESENTATION('',(#5501),#5505); +#5501 = CIRCLE('',#5502,3.); +#5502 = AXIS2_PLACEMENT_2D('',#5503,#5504); +#5503 = CARTESIAN_POINT('',(-21.99999999995,-37.59999999999)); +#5504 = DIRECTION('',(0.707106781187,-0.707106781187)); +#5505 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5506 = ORIENTED_EDGE('',*,*,#5507,.T.); +#5507 = EDGE_CURVE('',#5484,#3742,#5508,.T.); +#5508 = SURFACE_CURVE('',#5509,(#5513,#5520),.PCURVE_S1.); +#5509 = LINE('',#5510,#5511); +#5510 = CARTESIAN_POINT('',(-23.99999999994,-40.59999999999,4.5)); +#5511 = VECTOR('',#5512,1.); +#5512 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#5513 = PCURVE('',#3758,#5514); +#5514 = DEFINITIONAL_REPRESENTATION('',(#5515),#5519); +#5515 = LINE('',#5516,#5517); +#5516 = CARTESIAN_POINT('',(5.497787143782,0.)); +#5517 = VECTOR('',#5518,1.); +#5518 = DIRECTION('',(0.,-1.)); +#5519 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5520 = PCURVE('',#3786,#5521); +#5521 = DEFINITIONAL_REPRESENTATION('',(#5522),#5526); +#5522 = LINE('',#5523,#5524); +#5523 = CARTESIAN_POINT('',(1.,-1.331994833898E-28)); +#5524 = VECTOR('',#5525,1.); +#5525 = DIRECTION('',(0.,-1.)); +#5526 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5527 = ADVANCED_FACE('',(#5528),#3786,.F.); +#5528 = FACE_BOUND('',#5529,.T.); +#5529 = EDGE_LOOP('',(#5530,#5531,#5554,#5575)); +#5530 = ORIENTED_EDGE('',*,*,#5507,.F.); +#5531 = ORIENTED_EDGE('',*,*,#5532,.F.); +#5532 = EDGE_CURVE('',#5533,#5484,#5535,.T.); +#5533 = VERTEX_POINT('',#5534); +#5534 = CARTESIAN_POINT('',(-25.49999999994,-40.59999999999,36.5)); +#5535 = SURFACE_CURVE('',#5536,(#5540,#5547),.PCURVE_S1.); +#5536 = LINE('',#5537,#5538); +#5537 = CARTESIAN_POINT('',(-12.49999999996,-40.59999999999,36.5)); +#5538 = VECTOR('',#5539,1.); +#5539 = DIRECTION('',(1.,9.325873406851E-15,1.018942737706E-15)); +#5540 = PCURVE('',#3786,#5541); +#5541 = DEFINITIONAL_REPRESENTATION('',(#5542),#5546); +#5542 = LINE('',#5543,#5544); +#5543 = CARTESIAN_POINT('',(-10.49999999997,32.)); +#5544 = VECTOR('',#5545,1.); +#5545 = DIRECTION('',(-1.,1.018942737707E-15)); +#5546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5547 = PCURVE('',#2685,#5548); +#5548 = DEFINITIONAL_REPRESENTATION('',(#5549),#5553); +#5549 = LINE('',#5550,#5551); +#5550 = CARTESIAN_POINT('',(-10.49999999997,-40.59999999999)); +#5551 = VECTOR('',#5552,1.); +#5552 = DIRECTION('',(1.,9.325873406851E-15)); +#5553 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5554 = ORIENTED_EDGE('',*,*,#5555,.T.); +#5555 = EDGE_CURVE('',#5533,#3771,#5556,.T.); +#5556 = SURFACE_CURVE('',#5557,(#5561,#5568),.PCURVE_S1.); +#5557 = LINE('',#5558,#5559); +#5558 = CARTESIAN_POINT('',(-25.49999999994,-40.59999999999,4.5)); +#5559 = VECTOR('',#5560,1.); +#5560 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#5561 = PCURVE('',#3786,#5562); +#5562 = DEFINITIONAL_REPRESENTATION('',(#5563),#5567); +#5563 = LINE('',#5564,#5565); +#5564 = CARTESIAN_POINT('',(2.5,-3.334337904179E-28)); +#5565 = VECTOR('',#5566,1.); +#5566 = DIRECTION('',(0.,-1.)); +#5567 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5568 = PCURVE('',#3814,#5569); +#5569 = DEFINITIONAL_REPRESENTATION('',(#5570),#5574); +#5570 = LINE('',#5571,#5572); +#5571 = CARTESIAN_POINT('',(2.449293598295E-16,-2.)); +#5572 = VECTOR('',#5573,1.); +#5573 = DIRECTION('',(1.,0.)); +#5574 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5575 = ORIENTED_EDGE('',*,*,#3770,.F.); +#5576 = ADVANCED_FACE('',(#5577),#2956,.T.); +#5577 = FACE_BOUND('',#5578,.T.); +#5578 = EDGE_LOOP('',(#5579,#5580,#5581,#5603,#5604,#5654)); +#5579 = ORIENTED_EDGE('',*,*,#2939,.T.); +#5580 = ORIENTED_EDGE('',*,*,#5456,.T.); +#5581 = ORIENTED_EDGE('',*,*,#5582,.F.); +#5582 = EDGE_CURVE('',#4649,#5434,#5583,.T.); +#5583 = SURFACE_CURVE('',#5584,(#5589,#5596),.PCURVE_S1.); +#5584 = CIRCLE('',#5585,4.); +#5585 = AXIS2_PLACEMENT_3D('',#5586,#5587,#5588); +#5586 = CARTESIAN_POINT('',(-24.99999999994,34.600000000031,33.5)); +#5587 = DIRECTION('',(6.615789544246E-29,1.224646799147E-16,1.)); +#5588 = DIRECTION('',(0.707106781187,-0.707106781187,8.65956056235E-17) + ); +#5589 = PCURVE('',#2956,#5590); +#5590 = DEFINITIONAL_REPRESENTATION('',(#5591),#5595); +#5591 = LINE('',#5592,#5593); +#5592 = CARTESIAN_POINT('',(6.28318530718,-29.)); +#5593 = VECTOR('',#5594,1.); +#5594 = DIRECTION('',(-1.,0.)); +#5595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5596 = PCURVE('',#4687,#5597); +#5597 = DEFINITIONAL_REPRESENTATION('',(#5598),#5602); +#5598 = CIRCLE('',#5599,4.); +#5599 = AXIS2_PLACEMENT_2D('',#5600,#5601); +#5600 = CARTESIAN_POINT('',(-4.,-2.)); +#5601 = DIRECTION('',(0.707106781187,0.707106781187)); +#5602 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5603 = ORIENTED_EDGE('',*,*,#4648,.T.); +#5604 = ORIENTED_EDGE('',*,*,#5605,.T.); +#5605 = EDGE_CURVE('',#4626,#5606,#5608,.T.); +#5606 = VERTEX_POINT('',#5607); +#5607 = CARTESIAN_POINT('',(-24.99999999994,30.600000000031, + 31.149999999948)); +#5608 = SURFACE_CURVE('',#5609,(#5614,#5643),.PCURVE_S1.); +#5609 = ELLIPSE('',#5610,5.656854249493,4.); +#5610 = AXIS2_PLACEMENT_3D('',#5611,#5612,#5613); +#5611 = CARTESIAN_POINT('',(-24.99999999994,34.600000000031, + 31.149999999945)); +#5612 = DIRECTION('',(-0.707106781187,-5.623574421305E-13, + -0.707106781187)); +#5613 = DIRECTION('',(0.707106781187,5.621537007711E-13,-0.707106781187) + ); +#5614 = PCURVE('',#2956,#5615); +#5615 = DEFINITIONAL_REPRESENTATION('',(#5616),#5642); +#5616 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#5617,#5618,#5619,#5620,#5621, + #5622,#5623,#5624,#5625,#5626,#5627,#5628,#5629,#5630,#5631,#5632, + #5633,#5634,#5635,#5636,#5637,#5638,#5639,#5640,#5641), + .UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4), + (1.047197551197,1.070997495543,1.094797439888,1.118597384234, + 1.142397328579,1.166197272924,1.18999721727,1.213797161615, + 1.23759710596,1.261397050306,1.285196994651,1.308996938997, + 1.332796883342,1.356596827687,1.380396772033,1.404196716378, + 1.427996660723,1.451796605069,1.475596549414,1.49939649376, + 1.523196438105,1.54699638245,1.570796326796),.QUASI_UNIFORM_KNOTS.); +#5617 = CARTESIAN_POINT('',(0.261799387799,-24.64999999994)); +#5618 = CARTESIAN_POINT('',(0.269732702581,-24.67748175769)); +#5619 = CARTESIAN_POINT('',(0.285599332145,-24.73282309172)); +#5620 = CARTESIAN_POINT('',(0.30939927649,-24.81692086081)); +#5621 = CARTESIAN_POINT('',(0.333199220835,-24.90205694324)); +#5622 = CARTESIAN_POINT('',(0.356999165181,-24.98818306902)); +#5623 = CARTESIAN_POINT('',(0.380799109526,-25.07525046827)); +#5624 = CARTESIAN_POINT('',(0.404599053871,-25.16320982165)); +#5625 = CARTESIAN_POINT('',(0.428398998217,-25.25201130895)); +#5626 = CARTESIAN_POINT('',(0.452198942562,-25.34160463183)); +#5627 = CARTESIAN_POINT('',(0.475998886908,-25.43193904375)); +#5628 = CARTESIAN_POINT('',(0.499798831253,-25.52296337833)); +#5629 = CARTESIAN_POINT('',(0.523598775598,-25.6146260784)); +#5630 = CARTESIAN_POINT('',(0.547398719944,-25.70687522526)); +#5631 = CARTESIAN_POINT('',(0.571198664289,-25.799658568)); +#5632 = CARTESIAN_POINT('',(0.594998608634,-25.89292355315)); +#5633 = CARTESIAN_POINT('',(0.61879855298,-25.98661735443)); +#5634 = CARTESIAN_POINT('',(0.642598497325,-26.08068690268)); +#5635 = CARTESIAN_POINT('',(0.666398441671,-26.17507891593)); +#5636 = CARTESIAN_POINT('',(0.690198386016,-26.26973992948)); +#5637 = CARTESIAN_POINT('',(0.713998330361,-26.36461632653)); +#5638 = CARTESIAN_POINT('',(0.737798274707,-26.4596543673)); +#5639 = CARTESIAN_POINT('',(0.761598219052,-26.55480022417)); +#5640 = CARTESIAN_POINT('',(0.777464848616,-26.61826673776)); +#5641 = CARTESIAN_POINT('',(0.785398163397,-26.64999999994)); +#5642 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5643 = PCURVE('',#4609,#5644); +#5644 = DEFINITIONAL_REPRESENTATION('',(#5645),#5653); +#5645 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5646,#5647,#5648,#5649, +#5650,#5651,#5652),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5646 = CARTESIAN_POINT('',(-2.828427124825,-64.90000000003)); +#5647 = CARTESIAN_POINT('',(-2.828427124825,-57.97179676975)); +#5648 = CARTESIAN_POINT('',(5.656854249414,-61.43589838489)); +#5649 = CARTESIAN_POINT('',(14.142135623653,-64.90000000003)); +#5650 = CARTESIAN_POINT('',(5.656854249414,-68.36410161517)); +#5651 = CARTESIAN_POINT('',(-2.828427124825,-71.8282032303)); +#5652 = CARTESIAN_POINT('',(-2.828427124825,-64.90000000003)); +#5653 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5654 = ORIENTED_EDGE('',*,*,#5655,.T.); +#5655 = EDGE_CURVE('',#5606,#2940,#5656,.T.); +#5656 = SURFACE_CURVE('',#5657,(#5661,#5668),.PCURVE_S1.); +#5657 = LINE('',#5658,#5659); +#5658 = CARTESIAN_POINT('',(-24.99999999994,30.600000000031,4.5)); +#5659 = VECTOR('',#5660,1.); +#5660 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#5661 = PCURVE('',#2956,#5662); +#5662 = DEFINITIONAL_REPRESENTATION('',(#5663),#5667); +#5663 = LINE('',#5664,#5665); +#5664 = CARTESIAN_POINT('',(0.785398163397,0.)); +#5665 = VECTOR('',#5666,1.); +#5666 = DIRECTION('',(0.,1.)); +#5667 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5668 = PCURVE('',#2984,#5669); +#5669 = DEFINITIONAL_REPRESENTATION('',(#5670),#5674); +#5670 = LINE('',#5671,#5672); +#5671 = CARTESIAN_POINT('',(2.,-2.646586390055E-28)); +#5672 = VECTOR('',#5673,1.); +#5673 = DIRECTION('',(0.,-1.)); +#5674 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5675 = ADVANCED_FACE('',(#5676),#3706,.T.); +#5676 = FACE_BOUND('',#5677,.T.); +#5677 = EDGE_LOOP('',(#5678,#5679,#5702,#5750,#5751,#5773)); +#5678 = ORIENTED_EDGE('',*,*,#3689,.T.); +#5679 = ORIENTED_EDGE('',*,*,#5680,.T.); +#5680 = EDGE_CURVE('',#3662,#5681,#5683,.T.); +#5681 = VERTEX_POINT('',#5682); +#5682 = CARTESIAN_POINT('',(-24.99999999994,-30.59999999999, + 31.149999999996)); +#5683 = SURFACE_CURVE('',#5684,(#5688,#5695),.PCURVE_S1.); +#5684 = LINE('',#5685,#5686); +#5685 = CARTESIAN_POINT('',(-24.99999999994,-30.59999999999,4.5)); +#5686 = VECTOR('',#5687,1.); +#5687 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#5688 = PCURVE('',#3706,#5689); +#5689 = DEFINITIONAL_REPRESENTATION('',(#5690),#5694); +#5690 = LINE('',#5691,#5692); +#5691 = CARTESIAN_POINT('',(7.068583470577,0.)); +#5692 = VECTOR('',#5693,1.); +#5693 = DIRECTION('',(0.,1.)); +#5694 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5695 = PCURVE('',#3677,#5696); +#5696 = DEFINITIONAL_REPRESENTATION('',(#5697),#5701); +#5697 = LINE('',#5698,#5699); +#5698 = CARTESIAN_POINT('',(50.30000000008,6.656164771E-27)); +#5699 = VECTOR('',#5700,1.); +#5700 = DIRECTION('',(0.,1.)); +#5701 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5702 = ORIENTED_EDGE('',*,*,#5703,.T.); +#5703 = EDGE_CURVE('',#5681,#4700,#5704,.T.); +#5704 = SURFACE_CURVE('',#5705,(#5710,#5739),.PCURVE_S1.); +#5705 = ELLIPSE('',#5706,5.656854249493,4.); +#5706 = AXIS2_PLACEMENT_3D('',#5707,#5708,#5709); +#5707 = CARTESIAN_POINT('',(-24.99999999994,-34.59999999999,31.15)); +#5708 = DIRECTION('',(-0.707106781187,-5.623574421305E-13, + -0.707106781187)); +#5709 = DIRECTION('',(0.707106781187,5.621537007711E-13,-0.707106781187) + ); +#5710 = PCURVE('',#3706,#5711); +#5711 = DEFINITIONAL_REPRESENTATION('',(#5712),#5738); +#5712 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#5713,#5714,#5715,#5716,#5717, + #5718,#5719,#5720,#5721,#5722,#5723,#5724,#5725,#5726,#5727,#5728, + #5729,#5730,#5731,#5732,#5733,#5734,#5735,#5736,#5737), + .UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4), + (4.712388980385,4.736188924731,4.759988869076,4.783788813422, + 4.807588757767,4.831388702112,4.855188646458,4.878988590803, + 4.902788535149,4.926588479494,4.950388423839,4.974188368185, + 4.99798831253,5.021788256875,5.045588201221,5.069388145566, + 5.093188089912,5.116988034257,5.140787978602,5.164587922948, + 5.188387867293,5.212187811638,5.235987755984), + .QUASI_UNIFORM_KNOTS.); +#5713 = CARTESIAN_POINT('',(7.068583470577,26.649999999996)); +#5714 = CARTESIAN_POINT('',(7.060650155795,26.618266737815)); +#5715 = CARTESIAN_POINT('',(7.044783526232,26.554800224228)); +#5716 = CARTESIAN_POINT('',(7.020983581886,26.45965436735)); +#5717 = CARTESIAN_POINT('',(6.997183637541,26.364616326579)); +#5718 = CARTESIAN_POINT('',(6.973383693196,26.269739929528)); +#5719 = CARTESIAN_POINT('',(6.94958374885,26.175078915984)); +#5720 = CARTESIAN_POINT('',(6.925783804505,26.080686902738)); +#5721 = CARTESIAN_POINT('',(6.901983860159,25.986617354484)); +#5722 = CARTESIAN_POINT('',(6.878183915814,25.892923553199)); +#5723 = CARTESIAN_POINT('',(6.854383971469,25.799658568049)); +#5724 = CARTESIAN_POINT('',(6.830584027123,25.706875225311)); +#5725 = CARTESIAN_POINT('',(6.806784082778,25.614626078456)); +#5726 = CARTESIAN_POINT('',(6.782984138433,25.52296337838)); +#5727 = CARTESIAN_POINT('',(6.759184194087,25.431939043808)); +#5728 = CARTESIAN_POINT('',(6.735384249742,25.341604631887)); +#5729 = CARTESIAN_POINT('',(6.711584305396,25.252011309003)); +#5730 = CARTESIAN_POINT('',(6.687784361051,25.1632098217)); +#5731 = CARTESIAN_POINT('',(6.663984416706,25.075250468329)); +#5732 = CARTESIAN_POINT('',(6.64018447236,24.988183069078)); +#5733 = CARTESIAN_POINT('',(6.616384528015,24.902056943293)); +#5734 = CARTESIAN_POINT('',(6.592584583669,24.816920860862)); +#5735 = CARTESIAN_POINT('',(6.568784639324,24.732823091779)); +#5736 = CARTESIAN_POINT('',(6.552918009761,24.67748175774)); +#5737 = CARTESIAN_POINT('',(6.544984694979,24.649999999996)); +#5738 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5739 = PCURVE('',#4738,#5740); +#5740 = DEFINITIONAL_REPRESENTATION('',(#5741),#5749); +#5741 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5742,#5743,#5744,#5745, +#5746,#5747,#5748),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5742 = CARTESIAN_POINT('',(-2.828427124747,4.299999999998)); +#5743 = CARTESIAN_POINT('',(-2.828427124747,11.228203230274)); +#5744 = CARTESIAN_POINT('',(5.656854249492,7.764101615136)); +#5745 = CARTESIAN_POINT('',(14.14213562373,4.299999999998)); +#5746 = CARTESIAN_POINT('',(5.656854249492,0.835898384861)); +#5747 = CARTESIAN_POINT('',(-2.828427124747,-2.628203230277)); +#5748 = CARTESIAN_POINT('',(-2.828427124747,4.299999999998)); +#5749 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5750 = ORIENTED_EDGE('',*,*,#4699,.T.); +#5751 = ORIENTED_EDGE('',*,*,#5752,.F.); +#5752 = EDGE_CURVE('',#5411,#4672,#5753,.T.); +#5753 = SURFACE_CURVE('',#5754,(#5759,#5766),.PCURVE_S1.); +#5754 = CIRCLE('',#5755,4.); +#5755 = AXIS2_PLACEMENT_3D('',#5756,#5757,#5758); +#5756 = CARTESIAN_POINT('',(-24.99999999994,-34.59999999999,33.5)); +#5757 = DIRECTION('',(6.614876697963E-29,1.224646799147E-16,1.)); +#5758 = DIRECTION('',(0.707106781187,0.707106781187,-8.65956056236E-17) + ); +#5759 = PCURVE('',#3706,#5760); +#5760 = DEFINITIONAL_REPRESENTATION('',(#5761),#5765); +#5761 = LINE('',#5762,#5763); +#5762 = CARTESIAN_POINT('',(0.,29.)); +#5763 = VECTOR('',#5764,1.); +#5764 = DIRECTION('',(1.,0.)); +#5765 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5766 = PCURVE('',#4687,#5767); +#5767 = DEFINITIONAL_REPRESENTATION('',(#5768),#5772); +#5768 = CIRCLE('',#5769,4.); +#5769 = AXIS2_PLACEMENT_2D('',#5770,#5771); +#5770 = CARTESIAN_POINT('',(65.20000000003,-2.)); +#5771 = DIRECTION('',(-0.707106781187,0.707106781187)); +#5772 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5773 = ORIENTED_EDGE('',*,*,#5410,.T.); +#5774 = ADVANCED_FACE('',(#5775),#4738,.T.); +#5775 = FACE_BOUND('',#5776,.T.); +#5776 = EDGE_LOOP('',(#5777,#5778,#5801,#5822,#5823,#5824)); +#5777 = ORIENTED_EDGE('',*,*,#5703,.F.); +#5778 = ORIENTED_EDGE('',*,*,#5779,.T.); +#5779 = EDGE_CURVE('',#5681,#5780,#5782,.T.); +#5780 = VERTEX_POINT('',#5781); +#5781 = CARTESIAN_POINT('',(-31.17842712469,-30.59999999999, + 37.328427124746)); +#5782 = SURFACE_CURVE('',#5783,(#5787,#5794),.PCURVE_S1.); +#5783 = LINE('',#5784,#5785); +#5784 = CARTESIAN_POINT('',(-29.91249999997,-30.59999999999, + 36.062500000019)); +#5785 = VECTOR('',#5786,1.); +#5786 = DIRECTION('',(-0.707106781187,8.659560562355E-17,0.707106781187) + ); +#5787 = PCURVE('',#4738,#5788); +#5788 = DEFINITIONAL_REPRESENTATION('',(#5789),#5793); +#5789 = LINE('',#5790,#5791); +#5790 = CARTESIAN_POINT('',(9.77575124993,0.299999999995)); +#5791 = VECTOR('',#5792,1.); +#5792 = DIRECTION('',(1.,-5.606039374312E-13)); +#5793 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5794 = PCURVE('',#3677,#5795); +#5795 = DEFINITIONAL_REPRESENTATION('',(#5796),#5800); +#5796 = LINE('',#5797,#5798); +#5797 = CARTESIAN_POINT('',(45.387500000058,31.562500000019)); +#5798 = VECTOR('',#5799,1.); +#5799 = DIRECTION('',(-0.707106781187,0.707106781187)); +#5800 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5801 = ORIENTED_EDGE('',*,*,#5802,.F.); +#5802 = EDGE_CURVE('',#4976,#5780,#5803,.T.); +#5803 = SURFACE_CURVE('',#5804,(#5808,#5815),.PCURVE_S1.); +#5804 = LINE('',#5805,#5806); +#5805 = CARTESIAN_POINT('',(-31.17842712469,-30.3,37.328427124746)); +#5806 = VECTOR('',#5807,1.); +#5807 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#5808 = PCURVE('',#4738,#5809); +#5809 = DEFINITIONAL_REPRESENTATION('',(#5810),#5814); +#5810 = LINE('',#5811,#5812); +#5811 = CARTESIAN_POINT('',(11.566042558695,-8.80828086E-14)); +#5812 = VECTOR('',#5813,1.); +#5813 = DIRECTION('',(-7.030417873387E-16,-1.)); +#5814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5815 = PCURVE('',#5019,#5816); +#5816 = DEFINITIONAL_REPRESENTATION('',(#5817),#5821); +#5817 = LINE('',#5818,#5819); +#5818 = CARTESIAN_POINT('',(-0.392699081699,-5.329070518201E-14)); +#5819 = VECTOR('',#5820,1.); +#5820 = DIRECTION('',(0.,-1.)); +#5821 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5822 = ORIENTED_EDGE('',*,*,#4975,.F.); +#5823 = ORIENTED_EDGE('',*,*,#4927,.F.); +#5824 = ORIENTED_EDGE('',*,*,#4722,.F.); +#5825 = ADVANCED_FACE('',(#5826,#5899,#5934,#5969),#3677,.F.); +#5826 = FACE_BOUND('',#5827,.T.); +#5827 = EDGE_LOOP('',(#5828,#5829,#5830,#5853,#5876,#5898)); +#5828 = ORIENTED_EDGE('',*,*,#5680,.F.); +#5829 = ORIENTED_EDGE('',*,*,#3661,.F.); +#5830 = ORIENTED_EDGE('',*,*,#5831,.F.); +#5831 = EDGE_CURVE('',#5832,#3634,#5834,.T.); +#5832 = VERTEX_POINT('',#5833); +#5833 = CARTESIAN_POINT('',(-75.30000000002,-30.59999999999,38.5)); +#5834 = SURFACE_CURVE('',#5835,(#5839,#5846),.PCURVE_S1.); +#5835 = LINE('',#5836,#5837); +#5836 = CARTESIAN_POINT('',(-75.29999999997,-30.59999999999,21.5)); +#5837 = VECTOR('',#5838,1.); +#5838 = DIRECTION('',(-6.585885338563E-29,-1.224646799147E-16,-1.)); +#5839 = PCURVE('',#3677,#5840); +#5840 = DEFINITIONAL_REPRESENTATION('',(#5841),#5845); +#5841 = LINE('',#5842,#5843); +#5842 = CARTESIAN_POINT('',(5.250200274531E-11,17.)); +#5843 = VECTOR('',#5844,1.); +#5844 = DIRECTION('',(3.058063657533E-31,-1.)); +#5845 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5846 = PCURVE('',#3649,#5847); +#5847 = DEFINITIONAL_REPRESENTATION('',(#5848),#5852); +#5848 = LINE('',#5849,#5850); +#5849 = CARTESIAN_POINT('',(17.,0.299999999958)); +#5850 = VECTOR('',#5851,1.); +#5851 = DIRECTION('',(1.,-9.903448624721E-16)); +#5852 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5853 = ORIENTED_EDGE('',*,*,#5854,.F.); +#5854 = EDGE_CURVE('',#5855,#5832,#5857,.T.); +#5855 = VERTEX_POINT('',#5856); +#5856 = CARTESIAN_POINT('',(-34.00685424944,-30.59999999999,38.5)); +#5857 = SURFACE_CURVE('',#5858,(#5862,#5869),.PCURVE_S1.); +#5858 = LINE('',#5859,#5860); +#5859 = CARTESIAN_POINT('',(-53.82499999999,-30.59999999999,38.5)); +#5860 = VECTOR('',#5861,1.); +#5861 = DIRECTION('',(-1.,-1.247844962247E-31,-1.018942737707E-15)); +#5862 = PCURVE('',#3677,#5863); +#5863 = DEFINITIONAL_REPRESENTATION('',(#5864),#5868); +#5864 = LINE('',#5865,#5866); +#5865 = CARTESIAN_POINT('',(21.475000000038,34.)); +#5866 = VECTOR('',#5867,1.); +#5867 = DIRECTION('',(-1.,-1.018942737707E-15)); +#5868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5869 = PCURVE('',#5047,#5870); +#5870 = DEFINITIONAL_REPRESENTATION('',(#5871),#5875); +#5871 = LINE('',#5872,#5873); +#5872 = CARTESIAN_POINT('',(21.475000000038,0.299999999976)); +#5873 = VECTOR('',#5874,1.); +#5874 = DIRECTION('',(1.,-7.938040362974E-13)); +#5875 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5876 = ORIENTED_EDGE('',*,*,#5877,.F.); +#5877 = EDGE_CURVE('',#5780,#5855,#5878,.T.); +#5878 = SURFACE_CURVE('',#5879,(#5884,#5891),.PCURVE_S1.); +#5879 = CIRCLE('',#5880,4.); +#5880 = AXIS2_PLACEMENT_3D('',#5881,#5882,#5883); +#5881 = CARTESIAN_POINT('',(-34.00685424944,-30.59999999996,34.5)); +#5882 = DIRECTION('',(2.607556941129E-34,-1.,1.224646799147E-16)); +#5883 = DIRECTION('',(0.382683432365,1.131426112288E-16,0.923879532511) + ); +#5884 = PCURVE('',#3677,#5885); +#5885 = DEFINITIONAL_REPRESENTATION('',(#5886),#5890); +#5886 = CIRCLE('',#5887,4.); +#5887 = AXIS2_PLACEMENT_2D('',#5888,#5889); +#5888 = CARTESIAN_POINT('',(41.293145750584,30.)); +#5889 = DIRECTION('',(0.382683432365,0.923879532511)); +#5890 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5891 = PCURVE('',#5019,#5892); +#5892 = DEFINITIONAL_REPRESENTATION('',(#5893),#5897); +#5893 = LINE('',#5894,#5895); +#5894 = CARTESIAN_POINT('',(-6.28318530718,0.299999999978)); +#5895 = VECTOR('',#5896,1.); +#5896 = DIRECTION('',(1.,-2.854300450138E-12)); +#5897 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5898 = ORIENTED_EDGE('',*,*,#5779,.F.); +#5899 = FACE_BOUND('',#5900,.T.); +#5900 = EDGE_LOOP('',(#5901)); +#5901 = ORIENTED_EDGE('',*,*,#5902,.F.); +#5902 = EDGE_CURVE('',#5903,#5903,#5905,.T.); +#5903 = VERTEX_POINT('',#5904); +#5904 = CARTESIAN_POINT('',(-73.84999999997,-30.59999999999,7.)); +#5905 = SURFACE_CURVE('',#5906,(#5911,#5922),.PCURVE_S1.); +#5906 = CIRCLE('',#5907,1.05); +#5907 = AXIS2_PLACEMENT_3D('',#5908,#5909,#5910); +#5908 = CARTESIAN_POINT('',(-72.79999999997,-30.59999999999,7.)); +#5909 = DIRECTION('',(1.244603055572E-60,1.,-1.224646799147E-16)); +#5910 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#5911 = PCURVE('',#3677,#5912); +#5912 = DEFINITIONAL_REPRESENTATION('',(#5913),#5921); +#5913 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5914,#5915,#5916,#5917, +#5918,#5919,#5920),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5914 = CARTESIAN_POINT('',(3.550000000052,2.5)); +#5915 = CARTESIAN_POINT('',(3.550000000052,0.681346652053)); +#5916 = CARTESIAN_POINT('',(1.975000000052,1.590673326026)); +#5917 = CARTESIAN_POINT('',(0.400000000052,2.5)); +#5918 = CARTESIAN_POINT('',(1.975000000052,3.409326673974)); +#5919 = CARTESIAN_POINT('',(3.550000000052,4.318653347947)); +#5920 = CARTESIAN_POINT('',(3.550000000052,2.5)); +#5921 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5922 = PCURVE('',#5923,#5928); +#5923 = CYLINDRICAL_SURFACE('',#5924,1.05); +#5924 = AXIS2_PLACEMENT_3D('',#5925,#5926,#5927); +#5925 = CARTESIAN_POINT('',(-72.79999999997,-30.30000000003,7.)); +#5926 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#5927 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#5928 = DEFINITIONAL_REPRESENTATION('',(#5929),#5933); +#5929 = LINE('',#5930,#5931); +#5930 = CARTESIAN_POINT('',(12.566370614359,0.299999999958)); +#5931 = VECTOR('',#5932,1.); +#5932 = DIRECTION('',(-1.,0.)); +#5933 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5934 = FACE_BOUND('',#5935,.T.); +#5935 = EDGE_LOOP('',(#5936)); +#5936 = ORIENTED_EDGE('',*,*,#5937,.F.); +#5937 = EDGE_CURVE('',#5938,#5938,#5940,.T.); +#5938 = VERTEX_POINT('',#5939); +#5939 = CARTESIAN_POINT('',(-38.04999999995,-30.59999999996,7.)); +#5940 = SURFACE_CURVE('',#5941,(#5946,#5957),.PCURVE_S1.); +#5941 = CIRCLE('',#5942,1.05); +#5942 = AXIS2_PLACEMENT_3D('',#5943,#5944,#5945); +#5943 = CARTESIAN_POINT('',(-36.99999999995,-30.59999999996,7.)); +#5944 = DIRECTION('',(-1.244603055572E-60,1.,-1.224646799147E-16)); +#5945 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#5946 = PCURVE('',#3677,#5947); +#5947 = DEFINITIONAL_REPRESENTATION('',(#5948),#5956); +#5948 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5949,#5950,#5951,#5952, +#5953,#5954,#5955),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5949 = CARTESIAN_POINT('',(39.350000000073,2.5)); +#5950 = CARTESIAN_POINT('',(39.350000000073,0.681346652053)); +#5951 = CARTESIAN_POINT('',(37.775000000073,1.590673326026)); +#5952 = CARTESIAN_POINT('',(36.200000000073,2.5)); +#5953 = CARTESIAN_POINT('',(37.775000000073,3.409326673974)); +#5954 = CARTESIAN_POINT('',(39.350000000073,4.318653347947)); +#5955 = CARTESIAN_POINT('',(39.350000000073,2.5)); +#5956 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5957 = PCURVE('',#5958,#5963); +#5958 = CYLINDRICAL_SURFACE('',#5959,1.05); +#5959 = AXIS2_PLACEMENT_3D('',#5960,#5961,#5962); +#5960 = CARTESIAN_POINT('',(-36.99999999995,-30.30000000001,7.)); +#5961 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#5962 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#5963 = DEFINITIONAL_REPRESENTATION('',(#5964),#5968); +#5964 = LINE('',#5965,#5966); +#5965 = CARTESIAN_POINT('',(12.566370614359,0.299999999958)); +#5966 = VECTOR('',#5967,1.); +#5967 = DIRECTION('',(-1.,0.)); +#5968 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5969 = FACE_BOUND('',#5970,.T.); +#5970 = EDGE_LOOP('',(#5971)); +#5971 = ORIENTED_EDGE('',*,*,#5972,.F.); +#5972 = EDGE_CURVE('',#5973,#5973,#5975,.T.); +#5973 = VERTEX_POINT('',#5974); +#5974 = CARTESIAN_POINT('',(-73.84999999997,-30.59999999999,36.)); +#5975 = SURFACE_CURVE('',#5976,(#5981,#5992),.PCURVE_S1.); +#5976 = CIRCLE('',#5977,1.05); +#5977 = AXIS2_PLACEMENT_3D('',#5978,#5979,#5980); +#5978 = CARTESIAN_POINT('',(-72.79999999997,-30.59999999999,36.)); +#5979 = DIRECTION('',(1.244603055572E-60,1.,-1.224646799147E-16)); +#5980 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#5981 = PCURVE('',#3677,#5982); +#5982 = DEFINITIONAL_REPRESENTATION('',(#5983),#5991); +#5983 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#5984,#5985,#5986,#5987, +#5988,#5989,#5990),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#5984 = CARTESIAN_POINT('',(3.550000000053,31.5)); +#5985 = CARTESIAN_POINT('',(3.550000000053,29.681346652053)); +#5986 = CARTESIAN_POINT('',(1.975000000053,30.590673326026)); +#5987 = CARTESIAN_POINT('',(0.400000000053,31.5)); +#5988 = CARTESIAN_POINT('',(1.975000000053,32.409326673974)); +#5989 = CARTESIAN_POINT('',(3.550000000053,33.318653347947)); +#5990 = CARTESIAN_POINT('',(3.550000000053,31.5)); +#5991 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#5992 = PCURVE('',#5993,#5998); +#5993 = CYLINDRICAL_SURFACE('',#5994,1.05); +#5994 = AXIS2_PLACEMENT_3D('',#5995,#5996,#5997); +#5995 = CARTESIAN_POINT('',(-72.79999999997,-30.30000000003,36.)); +#5996 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#5997 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#5998 = DEFINITIONAL_REPRESENTATION('',(#5999),#6003); +#5999 = LINE('',#6000,#6001); +#6000 = CARTESIAN_POINT('',(6.28318530718,0.299999999958)); +#6001 = VECTOR('',#6002,1.); +#6002 = DIRECTION('',(-1.,0.)); +#6003 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6004 = ADVANCED_FACE('',(#6005),#3476,.T.); +#6005 = FACE_BOUND('',#6006,.T.); +#6006 = EDGE_LOOP('',(#6007,#6031,#6032,#6033)); +#6007 = ORIENTED_EDGE('',*,*,#6008,.T.); +#6008 = EDGE_CURVE('',#6009,#5246,#6011,.T.); +#6009 = VERTEX_POINT('',#6010); +#6010 = CARTESIAN_POINT('',(-33.00000000006,-41.59999999999,38.5)); +#6011 = SURFACE_CURVE('',#6012,(#6017,#6024),.PCURVE_S1.); +#6012 = CIRCLE('',#6013,3.); +#6013 = AXIS2_PLACEMENT_3D('',#6014,#6015,#6016); +#6014 = CARTESIAN_POINT('',(-30.00000000006,-41.59999999999,38.5)); +#6015 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6016 = DIRECTION('',(-0.707106781186,0.707106781187,-2.106606948913E-15 + )); +#6017 = PCURVE('',#3476,#6018); +#6018 = DEFINITIONAL_REPRESENTATION('',(#6019),#6023); +#6019 = LINE('',#6020,#6021); +#6020 = CARTESIAN_POINT('',(12.566370614359,17.)); +#6021 = VECTOR('',#6022,1.); +#6022 = DIRECTION('',(-1.,-4.523455546974E-15)); +#6023 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6024 = PCURVE('',#4811,#6025); +#6025 = DEFINITIONAL_REPRESENTATION('',(#6026),#6030); +#6026 = CIRCLE('',#6027,3.); +#6027 = AXIS2_PLACEMENT_2D('',#6028,#6029); +#6028 = CARTESIAN_POINT('',(59.000000000027,23.000000000029)); +#6029 = DIRECTION('',(0.707106781187,0.707106781186)); +#6030 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6031 = ORIENTED_EDGE('',*,*,#5245,.T.); +#6032 = ORIENTED_EDGE('',*,*,#3459,.T.); +#6033 = ORIENTED_EDGE('',*,*,#6034,.T.); +#6034 = EDGE_CURVE('',#3432,#6009,#6035,.T.); +#6035 = SURFACE_CURVE('',#6036,(#6040,#6047),.PCURVE_S1.); +#6036 = LINE('',#6037,#6038); +#6037 = CARTESIAN_POINT('',(-33.00000000006,-41.59999999999,21.5)); +#6038 = VECTOR('',#6039,1.); +#6039 = DIRECTION('',(-1.16838698865E-27,1.224646799147E-16,1.)); +#6040 = PCURVE('',#3476,#6041); +#6041 = DEFINITIONAL_REPRESENTATION('',(#6042),#6046); +#6042 = LINE('',#6043,#6044); +#6043 = CARTESIAN_POINT('',(7.068583470576,0.)); +#6044 = VECTOR('',#6045,1.); +#6045 = DIRECTION('',(0.,1.)); +#6046 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6047 = PCURVE('',#3447,#6048); +#6048 = DEFINITIONAL_REPRESENTATION('',(#6049),#6053); +#6049 = LINE('',#6050,#6051); +#6050 = CARTESIAN_POINT('',(17.,23.000000000029)); +#6051 = VECTOR('',#6052,1.); +#6052 = DIRECTION('',(-1.,-2.242250670306E-16)); +#6053 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6054 = ADVANCED_FACE('',(#6055,#6318,#6349,#6463,#6577,#6608,#6639, + #6753,#6784,#6815,#6841,#6871,#6901),#4811,.F.); +#6055 = FACE_BOUND('',#6056,.T.); +#6056 = EDGE_LOOP('',(#6057,#6058,#6081,#6105,#6128,#6152,#6175,#6199, + #6222,#6246,#6269,#6293,#6314,#6315,#6316,#6317)); +#6057 = ORIENTED_EDGE('',*,*,#6008,.F.); +#6058 = ORIENTED_EDGE('',*,*,#6059,.F.); +#6059 = EDGE_CURVE('',#6060,#6009,#6062,.T.); +#6060 = VERTEX_POINT('',#6061); +#6061 = CARTESIAN_POINT('',(-33.00000000009,-61.60000000002,38.5)); +#6062 = SURFACE_CURVE('',#6063,(#6067,#6074),.PCURVE_S1.); +#6063 = LINE('',#6064,#6065); +#6064 = CARTESIAN_POINT('',(-33.00000000009,-64.60000000002,38.5)); +#6065 = VECTOR('',#6066,1.); +#6066 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#6067 = PCURVE('',#4811,#6068); +#6068 = DEFINITIONAL_REPRESENTATION('',(#6069),#6073); +#6069 = LINE('',#6070,#6071); +#6070 = CARTESIAN_POINT('',(62.000000000027,-2.048493122522E-14)); +#6071 = VECTOR('',#6072,1.); +#6072 = DIRECTION('',(-2.286638207901E-16,1.)); +#6073 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6074 = PCURVE('',#3447,#6075); +#6075 = DEFINITIONAL_REPRESENTATION('',(#6076),#6080); +#6076 = LINE('',#6077,#6078); +#6077 = CARTESIAN_POINT('',(0.,0.)); +#6078 = VECTOR('',#6079,1.); +#6079 = DIRECTION('',(1.486465700216E-15,1.)); +#6080 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6081 = ORIENTED_EDGE('',*,*,#6082,.F.); +#6082 = EDGE_CURVE('',#6083,#6060,#6085,.T.); +#6083 = VERTEX_POINT('',#6084); +#6084 = CARTESIAN_POINT('',(-30.00000000009,-64.60000000002,38.5)); +#6085 = SURFACE_CURVE('',#6086,(#6091,#6098),.PCURVE_S1.); +#6086 = CIRCLE('',#6087,3.); +#6087 = AXIS2_PLACEMENT_3D('',#6088,#6089,#6090); +#6088 = CARTESIAN_POINT('',(-30.00000000009,-61.60000000002,38.5)); +#6089 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6090 = DIRECTION('',(-0.707106781188,-0.707106781186,4.858663463999E-16 + )); +#6091 = PCURVE('',#4811,#6092); +#6092 = DEFINITIONAL_REPRESENTATION('',(#6093),#6097); +#6093 = CIRCLE('',#6094,3.); +#6094 = AXIS2_PLACEMENT_2D('',#6095,#6096); +#6095 = CARTESIAN_POINT('',(59.000000000027,3.)); +#6096 = DIRECTION('',(0.707106781187,-0.707106781187)); +#6097 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6098 = PCURVE('',#3419,#6099); +#6099 = DEFINITIONAL_REPRESENTATION('',(#6100),#6104); +#6100 = LINE('',#6101,#6102); +#6101 = CARTESIAN_POINT('',(0.,-10.175)); +#6102 = VECTOR('',#6103,1.); +#6103 = DIRECTION('',(1.,4.52345554697E-15)); +#6104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6105 = ORIENTED_EDGE('',*,*,#6106,.T.); +#6106 = EDGE_CURVE('',#6083,#6107,#6109,.T.); +#6107 = VERTEX_POINT('',#6108); +#6108 = CARTESIAN_POINT('',(25.99999999993,-64.6000000001,38.5)); +#6109 = SURFACE_CURVE('',#6110,(#6114,#6121),.PCURVE_S1.); +#6110 = LINE('',#6111,#6112); +#6111 = CARTESIAN_POINT('',(-33.00000000009,-64.60000000002,38.5)); +#6112 = VECTOR('',#6113,1.); +#6113 = DIRECTION('',(1.,-1.439064838363E-12,1.146036670582E-15)); +#6114 = PCURVE('',#4811,#6115); +#6115 = DEFINITIONAL_REPRESENTATION('',(#6116),#6120); +#6116 = LINE('',#6117,#6118); +#6117 = CARTESIAN_POINT('',(62.000000000027,-2.048493122522E-14)); +#6118 = VECTOR('',#6119,1.); +#6119 = DIRECTION('',(-1.,-2.100863365323E-30)); +#6120 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6121 = PCURVE('',#3390,#6122); +#6122 = DEFINITIONAL_REPRESENTATION('',(#6123),#6127); +#6123 = LINE('',#6124,#6125); +#6124 = CARTESIAN_POINT('',(10.29999999999,20.350000000013)); +#6125 = VECTOR('',#6126,1.); +#6126 = DIRECTION('',(-1.,1.14603667058E-15)); +#6127 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6128 = ORIENTED_EDGE('',*,*,#6129,.F.); +#6129 = EDGE_CURVE('',#6130,#6107,#6132,.T.); +#6130 = VERTEX_POINT('',#6131); +#6131 = CARTESIAN_POINT('',(28.999999999935,-61.60000000011,38.5)); +#6132 = SURFACE_CURVE('',#6133,(#6138,#6145),.PCURVE_S1.); +#6133 = CIRCLE('',#6134,3.); +#6134 = AXIS2_PLACEMENT_3D('',#6135,#6136,#6137); +#6135 = CARTESIAN_POINT('',(25.999999999935,-61.6000000001,38.5)); +#6136 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6137 = DIRECTION('',(0.707106781186,-0.707106781188,2.106606948913E-15) + ); +#6138 = PCURVE('',#4811,#6139); +#6139 = DEFINITIONAL_REPRESENTATION('',(#6140),#6144); +#6140 = CIRCLE('',#6141,3.); +#6141 = AXIS2_PLACEMENT_2D('',#6142,#6143); +#6142 = CARTESIAN_POINT('',(3.,3.)); +#6143 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#6144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6145 = PCURVE('',#3362,#6146); +#6146 = DEFINITIONAL_REPRESENTATION('',(#6147),#6151); +#6147 = LINE('',#6148,#6149); +#6148 = CARTESIAN_POINT('',(2.6645352591E-15,-27.175)); +#6149 = VECTOR('',#6150,1.); +#6150 = DIRECTION('',(1.,-4.52345554697E-15)); +#6151 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6152 = ORIENTED_EDGE('',*,*,#6153,.T.); +#6153 = EDGE_CURVE('',#6130,#6154,#6156,.T.); +#6154 = VERTEX_POINT('',#6155); +#6155 = CARTESIAN_POINT('',(29.000000000112,61.599999999992,38.5)); +#6156 = SURFACE_CURVE('',#6157,(#6161,#6168),.PCURVE_S1.); +#6157 = LINE('',#6158,#6159); +#6158 = CARTESIAN_POINT('',(28.99999999993,-64.60000000011,38.5)); +#6159 = VECTOR('',#6160,1.); +#6160 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#6161 = PCURVE('',#4811,#6162); +#6162 = DEFINITIONAL_REPRESENTATION('',(#6163),#6167); +#6163 = LINE('',#6164,#6165); +#6164 = CARTESIAN_POINT('',(0.,0.)); +#6165 = VECTOR('',#6166,1.); +#6166 = DIRECTION('',(-2.286638207901E-16,1.)); +#6167 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6168 = PCURVE('',#3333,#6169); +#6169 = DEFINITIONAL_REPRESENTATION('',(#6170),#6174); +#6170 = LINE('',#6171,#6172); +#6171 = CARTESIAN_POINT('',(34.,2.423403319061E-15)); +#6172 = VECTOR('',#6173,1.); +#6173 = DIRECTION('',(-1.486465700216E-15,1.)); +#6174 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6175 = ORIENTED_EDGE('',*,*,#6176,.F.); +#6176 = EDGE_CURVE('',#6177,#6154,#6179,.T.); +#6177 = VERTEX_POINT('',#6178); +#6178 = CARTESIAN_POINT('',(26.000000000112,64.6,38.5)); +#6179 = SURFACE_CURVE('',#6180,(#6185,#6192),.PCURVE_S1.); +#6180 = CIRCLE('',#6181,3.); +#6181 = AXIS2_PLACEMENT_3D('',#6182,#6183,#6184); +#6182 = CARTESIAN_POINT('',(26.000000000112,61.599999999996,38.5)); +#6183 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6184 = DIRECTION('',(0.707106781187,0.707106781186,-4.858663464014E-16) + ); +#6185 = PCURVE('',#4811,#6186); +#6186 = DEFINITIONAL_REPRESENTATION('',(#6187),#6191); +#6187 = CIRCLE('',#6188,3.); +#6188 = AXIS2_PLACEMENT_2D('',#6189,#6190); +#6189 = CARTESIAN_POINT('',(3.,126.2000000001)); +#6190 = DIRECTION('',(-0.707106781186,0.707106781187)); +#6191 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6192 = PCURVE('',#3305,#6193); +#6193 = DEFINITIONAL_REPRESENTATION('',(#6194),#6198); +#6194 = LINE('',#6195,#6196); +#6195 = CARTESIAN_POINT('',(0.,-27.175)); +#6196 = VECTOR('',#6197,1.); +#6197 = DIRECTION('',(1.,0.)); +#6198 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6199 = ORIENTED_EDGE('',*,*,#6200,.F.); +#6200 = EDGE_CURVE('',#6201,#6177,#6203,.T.); +#6201 = VERTEX_POINT('',#6202); +#6202 = CARTESIAN_POINT('',(-30.,64.600000000081,38.5)); +#6203 = SURFACE_CURVE('',#6204,(#6208,#6215),.PCURVE_S1.); +#6204 = LINE('',#6205,#6206); +#6205 = CARTESIAN_POINT('',(23.000000000023,64.600000000005,38.5)); +#6206 = VECTOR('',#6207,1.); +#6207 = DIRECTION('',(1.,-1.437813204818E-12,-8.455304476901E-29)); +#6208 = PCURVE('',#4811,#6209); +#6209 = DEFINITIONAL_REPRESENTATION('',(#6210),#6214); +#6210 = LINE('',#6211,#6212); +#6211 = CARTESIAN_POINT('',(6.000000000093,129.2000000001)); +#6212 = VECTOR('',#6213,1.); +#6213 = DIRECTION('',(-1.,1.25163354538E-15)); +#6214 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6215 = PCURVE('',#3276,#6216); +#6216 = DEFINITIONAL_REPRESENTATION('',(#6217),#6221); +#6217 = LINE('',#6218,#6219); +#6218 = CARTESIAN_POINT('',(-45.70000000003,20.350000000013)); +#6219 = VECTOR('',#6220,1.); +#6220 = DIRECTION('',(-1.,-2.71468984945E-27)); +#6221 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6222 = ORIENTED_EDGE('',*,*,#6223,.F.); +#6223 = EDGE_CURVE('',#6224,#6201,#6226,.T.); +#6224 = VERTEX_POINT('',#6225); +#6225 = CARTESIAN_POINT('',(-33.,61.599999999996,38.5)); +#6226 = SURFACE_CURVE('',#6227,(#6232,#6239),.PCURVE_S1.); +#6227 = CIRCLE('',#6228,3.); +#6228 = AXIS2_PLACEMENT_3D('',#6229,#6230,#6231); +#6229 = CARTESIAN_POINT('',(-30.,61.599999999996,38.5)); +#6230 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6231 = DIRECTION('',(-0.707106781187,0.707106781187,-2.106606948913E-15 + )); +#6232 = PCURVE('',#4811,#6233); +#6233 = DEFINITIONAL_REPRESENTATION('',(#6234),#6238); +#6234 = CIRCLE('',#6235,3.); +#6235 = AXIS2_PLACEMENT_2D('',#6236,#6237); +#6236 = CARTESIAN_POINT('',(59.000000000116,126.20000000002)); +#6237 = DIRECTION('',(0.707106781188,0.707106781186)); +#6238 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6239 = PCURVE('',#3248,#6240); +#6240 = DEFINITIONAL_REPRESENTATION('',(#6241),#6245); +#6241 = LINE('',#6242,#6243); +#6242 = CARTESIAN_POINT('',(-6.28318530718,-10.175)); +#6243 = VECTOR('',#6244,1.); +#6244 = DIRECTION('',(1.,0.)); +#6245 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6246 = ORIENTED_EDGE('',*,*,#6247,.T.); +#6247 = EDGE_CURVE('',#6224,#6248,#6250,.T.); +#6248 = VERTEX_POINT('',#6249); +#6249 = CARTESIAN_POINT('',(-33.,41.599999999996,38.5)); +#6250 = SURFACE_CURVE('',#6251,(#6255,#6262),.PCURVE_S1.); +#6251 = LINE('',#6252,#6253); +#6252 = CARTESIAN_POINT('',(-33.,64.599999999996,38.5)); +#6253 = VECTOR('',#6254,1.); +#6254 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#6255 = PCURVE('',#4811,#6256); +#6256 = DEFINITIONAL_REPRESENTATION('',(#6257),#6261); +#6257 = LINE('',#6258,#6259); +#6258 = CARTESIAN_POINT('',(62.00000000012,129.20000000002)); +#6259 = VECTOR('',#6260,1.); +#6260 = DIRECTION('',(-1.443505730462E-12,-1.)); +#6261 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6262 = PCURVE('',#3219,#6263); +#6263 = DEFINITIONAL_REPRESENTATION('',(#6264),#6268); +#6264 = LINE('',#6265,#6266); +#6265 = CARTESIAN_POINT('',(0.,0.)); +#6266 = VECTOR('',#6267,1.); +#6267 = DIRECTION('',(1.486465700216E-15,1.)); +#6268 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6269 = ORIENTED_EDGE('',*,*,#6270,.F.); +#6270 = EDGE_CURVE('',#6271,#6248,#6273,.T.); +#6271 = VERTEX_POINT('',#6272); +#6272 = CARTESIAN_POINT('',(-30.,38.599999999996,38.5)); +#6273 = SURFACE_CURVE('',#6274,(#6279,#6286),.PCURVE_S1.); +#6274 = CIRCLE('',#6275,3.); +#6275 = AXIS2_PLACEMENT_3D('',#6276,#6277,#6278); +#6276 = CARTESIAN_POINT('',(-30.,41.599999999996,38.5)); +#6277 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6278 = DIRECTION('',(-0.707106781187,-0.707106781187,4.85866346403E-16) + ); +#6279 = PCURVE('',#4811,#6280); +#6280 = DEFINITIONAL_REPRESENTATION('',(#6281),#6285); +#6281 = CIRCLE('',#6282,3.); +#6282 = AXIS2_PLACEMENT_2D('',#6283,#6284); +#6283 = CARTESIAN_POINT('',(59.000000000087,106.20000000002)); +#6284 = DIRECTION('',(0.707106781186,-0.707106781188)); +#6285 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6286 = PCURVE('',#3191,#6287); +#6287 = DEFINITIONAL_REPRESENTATION('',(#6288),#6292); +#6288 = LINE('',#6289,#6290); +#6289 = CARTESIAN_POINT('',(12.566370614359,17.)); +#6290 = VECTOR('',#6291,1.); +#6291 = DIRECTION('',(-1.,-4.52345554697E-15)); +#6292 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6293 = ORIENTED_EDGE('',*,*,#6294,.F.); +#6294 = EDGE_CURVE('',#4849,#6271,#6295,.T.); +#6295 = SURFACE_CURVE('',#6296,(#6300,#6307),.PCURVE_S1.); +#6296 = LINE('',#6297,#6298); +#6297 = CARTESIAN_POINT('',(-17.49999999999,38.599999999996,38.5)); +#6298 = VECTOR('',#6299,1.); +#6299 = DIRECTION('',(-1.,-3.10862446895E-15,-1.018942737706E-15)); +#6300 = PCURVE('',#4811,#6301); +#6301 = DEFINITIONAL_REPRESENTATION('',(#6302),#6306); +#6302 = LINE('',#6303,#6304); +#6303 = CARTESIAN_POINT('',(46.500000000076,103.20000000004)); +#6304 = VECTOR('',#6305,1.); +#6305 = DIRECTION('',(1.,-1.442173462832E-12)); +#6306 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6307 = PCURVE('',#3162,#6308); +#6308 = DEFINITIONAL_REPRESENTATION('',(#6309),#6313); +#6309 = LINE('',#6310,#6311); +#6310 = CARTESIAN_POINT('',(15.500000000007,34.)); +#6311 = VECTOR('',#6312,1.); +#6312 = DIRECTION('',(-1.,-1.018942737707E-15)); +#6313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6314 = ORIENTED_EDGE('',*,*,#4871,.F.); +#6315 = ORIENTED_EDGE('',*,*,#4795,.F.); +#6316 = ORIENTED_EDGE('',*,*,#5190,.F.); +#6317 = ORIENTED_EDGE('',*,*,#5268,.F.); +#6318 = FACE_BOUND('',#6319,.T.); +#6319 = EDGE_LOOP('',(#6320)); +#6320 = ORIENTED_EDGE('',*,*,#6321,.T.); +#6321 = EDGE_CURVE('',#6322,#6322,#6324,.T.); +#6322 = VERTEX_POINT('',#6323); +#6323 = CARTESIAN_POINT('',(-11.25,47.850000000023,38.5)); +#6324 = SURFACE_CURVE('',#6325,(#6330,#6337),.PCURVE_S1.); +#6325 = CIRCLE('',#6326,1.05); +#6326 = AXIS2_PLACEMENT_3D('',#6327,#6328,#6329); +#6327 = CARTESIAN_POINT('',(-12.3,47.850000000023,38.5)); +#6328 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6329 = DIRECTION('',(-1.,-2.100863365323E-30,-1.146036670579E-15)); +#6330 = PCURVE('',#4811,#6331); +#6331 = DEFINITIONAL_REPRESENTATION('',(#6332),#6336); +#6332 = CIRCLE('',#6333,1.05); +#6333 = AXIS2_PLACEMENT_2D('',#6334,#6335); +#6334 = CARTESIAN_POINT('',(41.300000000095,112.45000000007)); +#6335 = DIRECTION('',(1.,-1.439064838363E-12)); +#6336 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6337 = PCURVE('',#6338,#6343); +#6338 = CYLINDRICAL_SURFACE('',#6339,1.05); +#6339 = AXIS2_PLACEMENT_3D('',#6340,#6341,#6342); +#6340 = CARTESIAN_POINT('',(-12.3,47.850000000023,38.5)); +#6341 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#6342 = DIRECTION('',(-1.,-2.847524422165E-42,6.616465975138E-29)); +#6343 = DEFINITIONAL_REPRESENTATION('',(#6344),#6348); +#6344 = LINE('',#6345,#6346); +#6345 = CARTESIAN_POINT('',(-6.28318530718,-1.06581410364E-13)); +#6346 = VECTOR('',#6347,1.); +#6347 = DIRECTION('',(1.,0.)); +#6348 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6349 = FACE_BOUND('',#6350,.T.); +#6350 = EDGE_LOOP('',(#6351,#6381,#6409,#6437)); +#6351 = ORIENTED_EDGE('',*,*,#6352,.T.); +#6352 = EDGE_CURVE('',#6353,#6355,#6357,.T.); +#6353 = VERTEX_POINT('',#6354); +#6354 = CARTESIAN_POINT('',(15.800000000045,52.19999999996,38.5)); +#6355 = VERTEX_POINT('',#6356); +#6356 = CARTESIAN_POINT('',(15.79999999998,43.499999999973,38.5)); +#6357 = SURFACE_CURVE('',#6358,(#6362,#6369),.PCURVE_S1.); +#6358 = LINE('',#6359,#6360); +#6359 = CARTESIAN_POINT('',(15.79999999961,-6.200000000027,38.5)); +#6360 = VECTOR('',#6361,1.); +#6361 = DIRECTION('',(-7.456615146551E-12,-1.,1.833155447154E-15)); +#6362 = PCURVE('',#4811,#6363); +#6363 = DEFINITIONAL_REPRESENTATION('',(#6364),#6368); +#6364 = LINE('',#6365,#6366); +#6365 = CARTESIAN_POINT('',(13.200000000405,58.400000000067)); +#6366 = VECTOR('',#6367,1.); +#6367 = DIRECTION('',(6.017550308188E-12,-1.)); +#6368 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6369 = PCURVE('',#6370,#6375); +#6370 = PLANE('',#6371); +#6371 = AXIS2_PLACEMENT_3D('',#6372,#6373,#6374); +#6372 = CARTESIAN_POINT('',(15.800000000045,52.19999999996,38.5)); +#6373 = DIRECTION('',(1.,-7.456615146551E-12,1.583211581664E-26)); +#6374 = DIRECTION('',(-7.456615146551E-12,-1.,2.103154404859E-15)); +#6375 = DEFINITIONAL_REPRESENTATION('',(#6376),#6380); +#6376 = LINE('',#6377,#6378); +#6377 = CARTESIAN_POINT('',(58.399999999987,-9.03386034843E-14)); +#6378 = VECTOR('',#6379,1.); +#6379 = DIRECTION('',(1.,2.699989577047E-16)); +#6380 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6381 = ORIENTED_EDGE('',*,*,#6382,.T.); +#6382 = EDGE_CURVE('',#6355,#6383,#6385,.T.); +#6383 = VERTEX_POINT('',#6384); +#6384 = CARTESIAN_POINT('',(-9.8,43.500000000006,38.5)); +#6385 = SURFACE_CURVE('',#6386,(#6390,#6397),.PCURVE_S1.); +#6386 = LINE('',#6387,#6388); +#6387 = CARTESIAN_POINT('',(22.400000000025,43.499999999965,38.5)); +#6388 = VECTOR('',#6389,1.); +#6389 = DIRECTION('',(-1.,1.2854300957E-12,-1.146036670581E-15)); +#6390 = PCURVE('',#4811,#6391); +#6391 = DEFINITIONAL_REPRESENTATION('',(#6392),#6396); +#6392 = LINE('',#6393,#6394); +#6393 = CARTESIAN_POINT('',(6.600000000061,108.10000000006)); +#6394 = VECTOR('',#6395,1.); +#6395 = DIRECTION('',(1.,-1.536347426633E-13)); +#6396 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6397 = PCURVE('',#6398,#6403); +#6398 = PLANE('',#6399); +#6399 = AXIS2_PLACEMENT_3D('',#6400,#6401,#6402); +#6400 = CARTESIAN_POINT('',(15.79999999998,43.499999999973,38.5)); +#6401 = DIRECTION('',(-1.2854300957E-12,-1.,2.132104200623E-15)); +#6402 = DIRECTION('',(-1.,1.2854300957E-12,-1.216328390511E-27)); +#6403 = DEFINITIONAL_REPRESENTATION('',(#6404),#6408); +#6404 = LINE('',#6405,#6406); +#6405 = CARTESIAN_POINT('',(-6.600000000045,-9.947598300641E-14)); +#6406 = VECTOR('',#6407,1.); +#6407 = DIRECTION('',(1.,1.14603667058E-15)); +#6408 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6409 = ORIENTED_EDGE('',*,*,#6410,.T.); +#6410 = EDGE_CURVE('',#6383,#6411,#6413,.T.); +#6411 = VERTEX_POINT('',#6412); +#6412 = CARTESIAN_POINT('',(-9.8,52.200000000026,38.5)); +#6413 = SURFACE_CURVE('',#6414,(#6418,#6425),.PCURVE_S1.); +#6414 = LINE('',#6415,#6416); +#6415 = CARTESIAN_POINT('',(-9.8,-10.55000000005,38.5)); +#6416 = VECTOR('',#6417,1.); +#6417 = DIRECTION('',(2.04178947057E-15,1.,-1.833155447163E-15)); +#6418 = PCURVE('',#4811,#6419); +#6419 = DEFINITIONAL_REPRESENTATION('',(#6420),#6424); +#6420 = LINE('',#6421,#6422); +#6421 = CARTESIAN_POINT('',(38.800000000008,54.050000000004)); +#6422 = VECTOR('',#6423,1.); +#6423 = DIRECTION('',(1.437023048892E-12,1.)); +#6424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6425 = PCURVE('',#6426,#6431); +#6426 = PLANE('',#6427); +#6427 = AXIS2_PLACEMENT_3D('',#6428,#6429,#6430); +#6428 = CARTESIAN_POINT('',(-9.8,43.500000000006,38.5)); +#6429 = DIRECTION('',(-1.,2.04178947057E-15,6.181135184439E-29)); +#6430 = DIRECTION('',(2.04178947057E-15,1.,-2.103154404859E-15)); +#6431 = DEFINITIONAL_REPRESENTATION('',(#6432),#6436); +#6432 = LINE('',#6433,#6434); +#6433 = CARTESIAN_POINT('',(-54.05000000005,-9.948732514528E-14)); +#6434 = VECTOR('',#6435,1.); +#6435 = DIRECTION('',(1.,-2.699989576962E-16)); +#6436 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6437 = ORIENTED_EDGE('',*,*,#6438,.T.); +#6438 = EDGE_CURVE('',#6411,#6353,#6439,.T.); +#6439 = SURFACE_CURVE('',#6440,(#6444,#6451),.PCURVE_S1.); +#6440 = LINE('',#6441,#6442); +#6441 = CARTESIAN_POINT('',(9.600000000116,52.199999999976,38.5)); +#6442 = VECTOR('',#6443,1.); +#6443 = DIRECTION('',(1.,-2.584737979201E-12,1.146036670584E-15)); +#6444 = PCURVE('',#4811,#6445); +#6445 = DEFINITIONAL_REPRESENTATION('',(#6446),#6450); +#6446 = LINE('',#6447,#6448); +#6447 = CARTESIAN_POINT('',(19.399999999982,116.80000000006)); +#6448 = VECTOR('',#6449,1.); +#6449 = DIRECTION('',(-1.,-1.145673140838E-12)); +#6450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6451 = PCURVE('',#6452,#6457); +#6452 = PLANE('',#6453); +#6453 = AXIS2_PLACEMENT_3D('',#6454,#6455,#6456); +#6454 = CARTESIAN_POINT('',(-9.8,52.200000000026,38.5)); +#6455 = DIRECTION('',(2.584737979201E-12,1.,-2.132104200623E-15)); +#6456 = DIRECTION('',(1.,-2.584737979201E-12,3.948973488964E-27)); +#6457 = DEFINITIONAL_REPRESENTATION('',(#6458),#6462); +#6458 = LINE('',#6459,#6460); +#6459 = CARTESIAN_POINT('',(19.400000000116,-9.947598300634E-14)); +#6460 = VECTOR('',#6461,1.); +#6461 = DIRECTION('',(1.,-1.14603667058E-15)); +#6462 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6463 = FACE_BOUND('',#6464,.T.); +#6464 = EDGE_LOOP('',(#6465,#6495,#6523,#6551)); +#6465 = ORIENTED_EDGE('',*,*,#6466,.T.); +#6466 = EDGE_CURVE('',#6467,#6469,#6471,.T.); +#6467 = VERTEX_POINT('',#6468); +#6468 = CARTESIAN_POINT('',(15.799999999991,41.899999999966,38.5)); +#6469 = VERTEX_POINT('',#6470); +#6470 = CARTESIAN_POINT('',(15.800000000003,38.600000000008,38.5)); +#6471 = SURFACE_CURVE('',#6472,(#6476,#6483),.PCURVE_S1.); +#6472 = LINE('',#6473,#6474); +#6473 = CARTESIAN_POINT('',(15.800000000185,-11.35000000009,38.5)); +#6474 = VECTOR('',#6475,1.); +#6475 = DIRECTION('',(3.641531520817E-12,-1.,1.833155447167E-15)); +#6476 = PCURVE('',#4811,#6477); +#6477 = DEFINITIONAL_REPRESENTATION('',(#6478),#6482); +#6478 = LINE('',#6479,#6480); +#6479 = CARTESIAN_POINT('',(13.199999999822,53.249999999997)); +#6480 = VECTOR('',#6481,1.); +#6481 = DIRECTION('',(-5.08059635918E-12,-1.)); +#6482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6483 = PCURVE('',#6484,#6489); +#6484 = PLANE('',#6485); +#6485 = AXIS2_PLACEMENT_3D('',#6486,#6487,#6488); +#6486 = CARTESIAN_POINT('',(15.799999999991,41.899999999966,38.5)); +#6487 = DIRECTION('',(1.,3.641531520817E-12,-7.830289311985E-27)); +#6488 = DIRECTION('',(3.641531520817E-12,-1.,2.103154404859E-15)); +#6489 = DEFINITIONAL_REPRESENTATION('',(#6490),#6494); +#6490 = LINE('',#6491,#6492); +#6491 = CARTESIAN_POINT('',(53.250000000064,-1.693865662745E-15)); +#6492 = VECTOR('',#6493,1.); +#6493 = DIRECTION('',(1.,2.69998957692E-16)); +#6494 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6495 = ORIENTED_EDGE('',*,*,#6496,.T.); +#6496 = EDGE_CURVE('',#6469,#6497,#6499,.T.); +#6497 = VERTEX_POINT('',#6498); +#6498 = CARTESIAN_POINT('',(-9.799999999997,38.6,38.5)); +#6499 = SURFACE_CURVE('',#6500,(#6504,#6511),.PCURVE_S1.); +#6500 = LINE('',#6501,#6502); +#6501 = CARTESIAN_POINT('',(22.39999999995,38.60000000001,38.5)); +#6502 = VECTOR('',#6503,1.); +#6503 = DIRECTION('',(-1.,-3.330669073875E-13,-1.146036670578E-15)); +#6504 = PCURVE('',#4811,#6505); +#6505 = DEFINITIONAL_REPRESENTATION('',(#6506),#6510); +#6506 = LINE('',#6507,#6508); +#6507 = CARTESIAN_POINT('',(6.600000000129,103.20000000011)); +#6508 = VECTOR('',#6509,1.); +#6509 = DIRECTION('',(1.,-1.772131745751E-12)); +#6510 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6511 = PCURVE('',#6512,#6517); +#6512 = PLANE('',#6513); +#6513 = AXIS2_PLACEMENT_3D('',#6514,#6515,#6516); +#6514 = CARTESIAN_POINT('',(15.800000000003,38.600000000008,38.5)); +#6515 = DIRECTION('',(3.330669073875E-13,-1.,2.132104200623E-15)); +#6516 = DIRECTION('',(-1.,-3.330669073875E-13,2.187620710783E-27)); +#6517 = DEFINITIONAL_REPRESENTATION('',(#6518),#6522); +#6518 = LINE('',#6519,#6520); +#6519 = CARTESIAN_POINT('',(-6.599999999946,-1.486930237863E-26)); +#6520 = VECTOR('',#6521,1.); +#6521 = DIRECTION('',(1.,1.146036670581E-15)); +#6522 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6523 = ORIENTED_EDGE('',*,*,#6524,.T.); +#6524 = EDGE_CURVE('',#6497,#6525,#6527,.T.); +#6525 = VERTEX_POINT('',#6526); +#6526 = CARTESIAN_POINT('',(-9.799999999999,41.899999999999,38.5)); +#6527 = SURFACE_CURVE('',#6528,(#6532,#6539),.PCURVE_S1.); +#6528 = LINE('',#6529,#6530); +#6529 = CARTESIAN_POINT('',(-9.799999999961,-13.00000000007,38.5)); +#6530 = VECTOR('',#6531,1.); +#6531 = DIRECTION('',(-6.917025874635E-13,1.,-1.833155447164E-15)); +#6532 = PCURVE('',#4811,#6533); +#6533 = DEFINITIONAL_REPRESENTATION('',(#6534),#6538); +#6534 = LINE('',#6535,#6536); +#6535 = CARTESIAN_POINT('',(38.799999999966,51.599999999987)); +#6536 = VECTOR('',#6537,1.); +#6537 = DIRECTION('',(2.130767425827E-12,1.)); +#6538 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6539 = PCURVE('',#6540,#6545); +#6540 = PLANE('',#6541); +#6541 = AXIS2_PLACEMENT_3D('',#6542,#6543,#6544); +#6542 = CARTESIAN_POINT('',(-9.799999999997,38.6,38.5)); +#6543 = DIRECTION('',(-1.,-6.917025874635E-13,1.540946652064E-27)); +#6544 = DIRECTION('',(-6.917025874635E-13,1.,-2.103154404859E-15)); +#6545 = DEFINITIONAL_REPRESENTATION('',(#6546),#6550); +#6546 = LINE('',#6547,#6548); +#6547 = CARTESIAN_POINT('',(-51.60000000007,-5.164070430749E-15)); +#6548 = VECTOR('',#6549,1.); +#6549 = DIRECTION('',(1.,-2.699989576954E-16)); +#6550 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6551 = ORIENTED_EDGE('',*,*,#6552,.T.); +#6552 = EDGE_CURVE('',#6525,#6467,#6553,.T.); +#6553 = SURFACE_CURVE('',#6554,(#6558,#6565),.PCURVE_S1.); +#6554 = LINE('',#6555,#6556); +#6555 = CARTESIAN_POINT('',(9.600000000034,41.899999999974,38.5)); +#6556 = VECTOR('',#6557,1.); +#6557 = DIRECTION('',(1.,-1.288552597956E-12,1.146036670581E-15)); +#6558 = PCURVE('',#4811,#6559); +#6559 = DEFINITIONAL_REPRESENTATION('',(#6560),#6564); +#6560 = LINE('',#6561,#6562); +#6561 = CARTESIAN_POINT('',(19.400000000049,106.50000000005)); +#6562 = VECTOR('',#6563,1.); +#6563 = DIRECTION('',(-1.,1.50512240407E-13)); +#6564 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6565 = PCURVE('',#6566,#6571); +#6566 = PLANE('',#6567); +#6567 = AXIS2_PLACEMENT_3D('',#6568,#6569,#6570); +#6568 = CARTESIAN_POINT('',(-9.799999999999,41.899999999999,38.5)); +#6569 = DIRECTION('',(1.288552597956E-12,1.,-2.132104200623E-15)); +#6570 = DIRECTION('',(1.,-1.288552597956E-12,1.222895494885E-27)); +#6571 = DEFINITIONAL_REPRESENTATION('',(#6572),#6576); +#6572 = LINE('',#6573,#6574); +#6573 = CARTESIAN_POINT('',(19.400000000033,2.243838862369E-26)); +#6574 = VECTOR('',#6575,1.); +#6575 = DIRECTION('',(1.,-1.14603667058E-15)); +#6576 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6577 = FACE_BOUND('',#6578,.T.); +#6578 = EDGE_LOOP('',(#6579)); +#6579 = ORIENTED_EDGE('',*,*,#6580,.T.); +#6580 = EDGE_CURVE('',#6581,#6581,#6583,.T.); +#6581 = VERTEX_POINT('',#6582); +#6582 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,38.5)); +#6583 = SURFACE_CURVE('',#6584,(#6589,#6596),.PCURVE_S1.); +#6584 = CIRCLE('',#6585,1.05); +#6585 = AXIS2_PLACEMENT_3D('',#6586,#6587,#6588); +#6586 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,38.5)); +#6587 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6588 = DIRECTION('',(-1.,-2.100863365323E-30,-1.146036670579E-15)); +#6589 = PCURVE('',#4811,#6590); +#6590 = DEFINITIONAL_REPRESENTATION('',(#6591),#6595); +#6591 = CIRCLE('',#6592,1.05); +#6592 = AXIS2_PLACEMENT_2D('',#6593,#6594); +#6593 = CARTESIAN_POINT('',(10.700000000064,112.45000000006)); +#6594 = DIRECTION('',(1.,-1.439064838363E-12)); +#6595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6596 = PCURVE('',#6597,#6602); +#6597 = CYLINDRICAL_SURFACE('',#6598,1.05); +#6598 = AXIS2_PLACEMENT_3D('',#6599,#6600,#6601); +#6599 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,38.5)); +#6600 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#6601 = DIRECTION('',(-1.,-2.847524422165E-42,6.616465975138E-29)); +#6602 = DEFINITIONAL_REPRESENTATION('',(#6603),#6607); +#6603 = LINE('',#6604,#6605); +#6604 = CARTESIAN_POINT('',(-6.28318530718,-1.06581410364E-13)); +#6605 = VECTOR('',#6606,1.); +#6606 = DIRECTION('',(1.,0.)); +#6607 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6608 = FACE_BOUND('',#6609,.T.); +#6609 = EDGE_LOOP('',(#6610)); +#6610 = ORIENTED_EDGE('',*,*,#6611,.T.); +#6611 = EDGE_CURVE('',#6612,#6612,#6614,.T.); +#6612 = VERTEX_POINT('',#6613); +#6613 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,38.5)); +#6614 = SURFACE_CURVE('',#6615,(#6620,#6627),.PCURVE_S1.); +#6615 = CIRCLE('',#6616,1.05); +#6616 = AXIS2_PLACEMENT_3D('',#6617,#6618,#6619); +#6617 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,38.5)); +#6618 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6619 = DIRECTION('',(-1.,-2.100863365323E-30,-1.146036670579E-15)); +#6620 = PCURVE('',#4811,#6621); +#6621 = DEFINITIONAL_REPRESENTATION('',(#6622),#6626); +#6622 = CIRCLE('',#6623,1.05); +#6623 = AXIS2_PLACEMENT_2D('',#6624,#6625); +#6624 = CARTESIAN_POINT('',(46.204445042195,31.36163992022)); +#6625 = DIRECTION('',(1.,-1.439064838363E-12)); +#6626 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6627 = PCURVE('',#6628,#6633); +#6628 = CYLINDRICAL_SURFACE('',#6629,1.05); +#6629 = AXIS2_PLACEMENT_3D('',#6630,#6631,#6632); +#6630 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,38.5)); +#6631 = DIRECTION('',(-6.616465975138E-29,-2.093457286763E-15,-1.)); +#6632 = DIRECTION('',(-1.,-2.792608513395E-42,6.616465975138E-29)); +#6633 = DEFINITIONAL_REPRESENTATION('',(#6634),#6638); +#6634 = LINE('',#6635,#6636); +#6635 = CARTESIAN_POINT('',(0.,-9.947598300641E-14)); +#6636 = VECTOR('',#6637,1.); +#6637 = DIRECTION('',(1.,0.)); +#6638 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6639 = FACE_BOUND('',#6640,.T.); +#6640 = EDGE_LOOP('',(#6641,#6671,#6699,#6727)); +#6641 = ORIENTED_EDGE('',*,*,#6642,.T.); +#6642 = EDGE_CURVE('',#6643,#6645,#6647,.T.); +#6643 = VERTEX_POINT('',#6644); +#6644 = CARTESIAN_POINT('',(15.800000000051,57.099999999995,38.5)); +#6645 = VERTEX_POINT('',#6646); +#6646 = CARTESIAN_POINT('',(15.800000000046,53.79999999996,38.5)); +#6647 = SURFACE_CURVE('',#6648,(#6652,#6659),.PCURVE_S1.); +#6648 = LINE('',#6649,#6650); +#6649 = CARTESIAN_POINT('',(15.799999999958,-3.750000000049,38.5)); +#6650 = VECTOR('',#6651,1.); +#6651 = DIRECTION('',(-1.526052012014E-12,-1.,1.833155447161E-15)); +#6652 = PCURVE('',#4811,#6653); +#6653 = DEFINITIONAL_REPRESENTATION('',(#6654),#6658); +#6654 = LINE('',#6655,#6656); +#6655 = CARTESIAN_POINT('',(13.20000000006,60.850000000045)); +#6656 = VECTOR('',#6657,1.); +#6657 = DIRECTION('',(8.698717365083E-14,-1.)); +#6658 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6659 = PCURVE('',#6660,#6665); +#6660 = PLANE('',#6661); +#6661 = AXIS2_PLACEMENT_3D('',#6662,#6663,#6664); +#6662 = CARTESIAN_POINT('',(15.800000000051,57.099999999995,38.5)); +#6663 = DIRECTION('',(1.,-1.526052012014E-12,3.187537245432E-27)); +#6664 = DIRECTION('',(-1.526052012014E-12,-1.,2.103154404859E-15)); +#6665 = DEFINITIONAL_REPRESENTATION('',(#6666),#6670); +#6666 = LINE('',#6667,#6668); +#6667 = CARTESIAN_POINT('',(60.850000000044,-8.518587519227E-14)); +#6668 = VECTOR('',#6669,1.); +#6669 = DIRECTION('',(1.,2.699989576979E-16)); +#6670 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6671 = ORIENTED_EDGE('',*,*,#6672,.T.); +#6672 = EDGE_CURVE('',#6645,#6673,#6675,.T.); +#6673 = VERTEX_POINT('',#6674); +#6674 = CARTESIAN_POINT('',(-9.8,53.799999999986,38.5)); +#6675 = SURFACE_CURVE('',#6676,(#6680,#6687),.PCURVE_S1.); +#6676 = LINE('',#6677,#6678); +#6677 = CARTESIAN_POINT('',(22.400000000048,53.799999999953,38.5)); +#6678 = VECTOR('',#6679,1.); +#6679 = DIRECTION('',(-1.,1.009609063017E-12,-1.146036670581E-15)); +#6680 = PCURVE('',#4811,#6681); +#6681 = DEFINITIONAL_REPRESENTATION('',(#6682),#6686); +#6682 = LINE('',#6683,#6684); +#6683 = CARTESIAN_POINT('',(6.600000000053,118.40000000005)); +#6684 = VECTOR('',#6685,1.); +#6685 = DIRECTION('',(1.,-4.294557753464E-13)); +#6686 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6687 = PCURVE('',#6688,#6693); +#6688 = PLANE('',#6689); +#6689 = AXIS2_PLACEMENT_3D('',#6690,#6691,#6692); +#6690 = CARTESIAN_POINT('',(15.800000000046,53.79999999996,38.5)); +#6691 = DIRECTION('',(-1.009609063017E-12,-1.,2.132104200623E-15)); +#6692 = DIRECTION('',(-1.,1.009609063017E-12,-6.362341706706E-28)); +#6693 = DEFINITIONAL_REPRESENTATION('',(#6694),#6698); +#6694 = LINE('',#6695,#6696); +#6695 = CARTESIAN_POINT('',(-6.600000000002,-9.947598300641E-14)); +#6696 = VECTOR('',#6697,1.); +#6697 = DIRECTION('',(1.,1.14603667058E-15)); +#6698 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6699 = ORIENTED_EDGE('',*,*,#6700,.T.); +#6700 = EDGE_CURVE('',#6673,#6701,#6703,.T.); +#6701 = VERTEX_POINT('',#6702); +#6702 = CARTESIAN_POINT('',(-9.8,57.099999999985,38.5)); +#6703 = SURFACE_CURVE('',#6704,(#6708,#6715),.PCURVE_S1.); +#6704 = LINE('',#6705,#6706); +#6705 = CARTESIAN_POINT('',(-9.8,-5.400000000064,38.5)); +#6706 = VECTOR('',#6707,1.); +#6707 = DIRECTION('',(-2.927677884444E-42,1.,-1.833155447163E-15)); +#6708 = PCURVE('',#4811,#6709); +#6709 = DEFINITIONAL_REPRESENTATION('',(#6710),#6714); +#6710 = LINE('',#6711,#6712); +#6711 = CARTESIAN_POINT('',(38.800000000016,59.199999999994)); +#6712 = VECTOR('',#6713,1.); +#6713 = DIRECTION('',(1.439064838363E-12,1.)); +#6714 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6715 = PCURVE('',#6716,#6721); +#6716 = PLANE('',#6717); +#6717 = AXIS2_PLACEMENT_3D('',#6718,#6719,#6720); +#6718 = CARTESIAN_POINT('',(-9.8,53.799999999986,38.5)); +#6719 = DIRECTION('',(-1.,-2.806387778012E-42,6.616465975138E-29)); +#6720 = DIRECTION('',(-2.945542273614E-42,1.,-2.103154404859E-15)); +#6721 = DEFINITIONAL_REPRESENTATION('',(#6722),#6726); +#6722 = LINE('',#6723,#6724); +#6723 = CARTESIAN_POINT('',(-59.20000000004,-8.865607996028E-14)); +#6724 = VECTOR('',#6725,1.); +#6725 = DIRECTION('',(1.,-2.699989576962E-16)); +#6726 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6727 = ORIENTED_EDGE('',*,*,#6728,.T.); +#6728 = EDGE_CURVE('',#6701,#6643,#6729,.T.); +#6729 = SURFACE_CURVE('',#6730,(#6734,#6741),.PCURVE_S1.); +#6730 = LINE('',#6731,#6732); +#6731 = CARTESIAN_POINT('',(9.599999999942,57.099999999993,38.5)); +#6732 = VECTOR('',#6733,1.); +#6733 = DIRECTION('',(1.,3.861494457517E-13,1.146036670578E-15)); +#6734 = PCURVE('',#4811,#6735); +#6735 = DEFINITIONAL_REPRESENTATION('',(#6736),#6740); +#6736 = LINE('',#6737,#6738); +#6737 = CARTESIAN_POINT('',(19.400000000164,121.70000000007)); +#6738 = VECTOR('',#6739,1.); +#6739 = DIRECTION('',(-1.,1.825214284115E-12)); +#6740 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6741 = PCURVE('',#6742,#6747); +#6742 = PLANE('',#6743); +#6743 = AXIS2_PLACEMENT_3D('',#6744,#6745,#6746); +#6744 = CARTESIAN_POINT('',(-9.8,57.099999999985,38.5)); +#6745 = DIRECTION('',(-3.861494457517E-13,1.,-2.132104200623E-15)); +#6746 = DIRECTION('',(1.,3.861494457517E-13,-2.299261485165E-27)); +#6747 = DEFINITIONAL_REPRESENTATION('',(#6748),#6752); +#6748 = LINE('',#6749,#6750); +#6749 = CARTESIAN_POINT('',(19.399999999942,-9.947598300646E-14)); +#6750 = VECTOR('',#6751,1.); +#6751 = DIRECTION('',(1.,-1.146036670581E-15)); +#6752 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6753 = FACE_BOUND('',#6754,.T.); +#6754 = EDGE_LOOP('',(#6755)); +#6755 = ORIENTED_EDGE('',*,*,#6756,.T.); +#6756 = EDGE_CURVE('',#6757,#6757,#6759,.T.); +#6757 = VERTEX_POINT('',#6758); +#6758 = CARTESIAN_POINT('',(1.05,1.307051927199E-16,38.5)); +#6759 = SURFACE_CURVE('',#6760,(#6765,#6772),.PCURVE_S1.); +#6760 = CIRCLE('',#6761,1.05); +#6761 = AXIS2_PLACEMENT_3D('',#6762,#6763,#6764); +#6762 = CARTESIAN_POINT('',(0.,2.117278810017E-18,38.5)); +#6763 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6764 = DIRECTION('',(-1.,-2.100863365323E-30,-1.146036670579E-15)); +#6765 = PCURVE('',#4811,#6766); +#6766 = DEFINITIONAL_REPRESENTATION('',(#6767),#6771); +#6767 = CIRCLE('',#6768,1.05); +#6768 = AXIS2_PLACEMENT_2D('',#6769,#6770); +#6769 = CARTESIAN_POINT('',(29.000000000023,64.600000000071)); +#6770 = DIRECTION('',(1.,-1.439064838363E-12)); +#6771 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6772 = PCURVE('',#6773,#6778); +#6773 = CYLINDRICAL_SURFACE('',#6774,1.05); +#6774 = AXIS2_PLACEMENT_3D('',#6775,#6776,#6777); +#6775 = CARTESIAN_POINT('',(0.,2.117278810017E-18,38.5)); +#6776 = DIRECTION('',(-6.616465975138E-29,-2.103154404859E-15,-1.)); +#6777 = DIRECTION('',(-1.,-2.806387778012E-42,6.616465975138E-29)); +#6778 = DEFINITIONAL_REPRESENTATION('',(#6779),#6783); +#6779 = LINE('',#6780,#6781); +#6780 = CARTESIAN_POINT('',(0.,-9.947598300641E-14)); +#6781 = VECTOR('',#6782,1.); +#6782 = DIRECTION('',(1.,0.)); +#6783 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6784 = FACE_BOUND('',#6785,.T.); +#6785 = EDGE_LOOP('',(#6786)); +#6786 = ORIENTED_EDGE('',*,*,#6787,.T.); +#6787 = EDGE_CURVE('',#6788,#6788,#6790,.T.); +#6788 = VERTEX_POINT('',#6789); +#6789 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,38.5)); +#6790 = SURFACE_CURVE('',#6791,(#6796,#6803),.PCURVE_S1.); +#6791 = CIRCLE('',#6792,1.05); +#6792 = AXIS2_PLACEMENT_3D('',#6793,#6794,#6795); +#6793 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,38.5)); +#6794 = DIRECTION('',(1.146036670579E-15,-1.833155447163E-15,-1.)); +#6795 = DIRECTION('',(-1.,-2.100863365323E-30,-1.146036670579E-15)); +#6796 = PCURVE('',#4811,#6797); +#6797 = DEFINITIONAL_REPRESENTATION('',(#6798),#6802); +#6798 = CIRCLE('',#6799,1.05); +#6799 = AXIS2_PLACEMENT_2D('',#6800,#6801); +#6800 = CARTESIAN_POINT('',(14.488887394352,22.863481861003)); +#6801 = DIRECTION('',(1.,-1.439064838363E-12)); +#6802 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6803 = PCURVE('',#6804,#6809); +#6804 = CYLINDRICAL_SURFACE('',#6805,1.05); +#6805 = AXIS2_PLACEMENT_3D('',#6806,#6807,#6808); +#6806 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,38.5)); +#6807 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#6808 = DIRECTION('',(-1.,-2.847524422165E-42,6.616465975138E-29)); +#6809 = DEFINITIONAL_REPRESENTATION('',(#6810),#6814); +#6810 = LINE('',#6811,#6812); +#6811 = CARTESIAN_POINT('',(-6.28318530718,-9.947598300641E-14)); +#6812 = VECTOR('',#6813,1.); +#6813 = DIRECTION('',(1.,0.)); +#6814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6815 = FACE_BOUND('',#6816,.T.); +#6816 = EDGE_LOOP('',(#6817)); +#6817 = ORIENTED_EDGE('',*,*,#6818,.T.); +#6818 = EDGE_CURVE('',#6819,#6819,#6821,.T.); +#6819 = VERTEX_POINT('',#6820); +#6820 = CARTESIAN_POINT('',(-31.05000000007,61.599999999999,38.5)); +#6821 = SURFACE_CURVE('',#6822,(#6827,#6834),.PCURVE_S1.); +#6822 = CIRCLE('',#6823,1.05); +#6823 = AXIS2_PLACEMENT_3D('',#6824,#6825,#6826); +#6824 = CARTESIAN_POINT('',(-30.00000000007,61.6,38.5)); +#6825 = DIRECTION('',(-2.629808818222E-28,1.475342777831E-16,-1.)); +#6826 = DIRECTION('',(1.,1.443734394282E-12,-4.998057065114E-29)); +#6827 = PCURVE('',#4811,#6828); +#6828 = DEFINITIONAL_REPRESENTATION('',(#6829),#6833); +#6829 = CIRCLE('',#6830,1.05); +#6830 = AXIS2_PLACEMENT_2D('',#6831,#6832); +#6831 = CARTESIAN_POINT('',(59.000000000186,126.20000000002)); +#6832 = DIRECTION('',(-1.,2.882799232645E-12)); +#6833 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6834 = PCURVE('',#4292,#6835); +#6835 = DEFINITIONAL_REPRESENTATION('',(#6836),#6840); +#6836 = LINE('',#6837,#6838); +#6837 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#6838 = VECTOR('',#6839,1.); +#6839 = DIRECTION('',(1.,0.)); +#6840 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6841 = FACE_BOUND('',#6842,.T.); +#6842 = EDGE_LOOP('',(#6843)); +#6843 = ORIENTED_EDGE('',*,*,#6844,.F.); +#6844 = EDGE_CURVE('',#6845,#6845,#6847,.T.); +#6845 = VERTEX_POINT('',#6846); +#6846 = CARTESIAN_POINT('',(27.050000000019,61.599999999999,38.5)); +#6847 = SURFACE_CURVE('',#6848,(#6853,#6864),.PCURVE_S1.); +#6848 = CIRCLE('',#6849,1.05); +#6849 = AXIS2_PLACEMENT_3D('',#6850,#6851,#6852); +#6850 = CARTESIAN_POINT('',(26.000000000019,61.6,38.5)); +#6851 = DIRECTION('',(-1.275736879908E-28,-1.475342777831E-16,1.)); +#6852 = DIRECTION('',(-1.,1.434852610085E-12,8.411625556336E-29)); +#6853 = PCURVE('',#4811,#6854); +#6854 = DEFINITIONAL_REPRESENTATION('',(#6855),#6863); +#6855 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#6856,#6857,#6858,#6859, +#6860,#6861,#6862),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#6856 = CARTESIAN_POINT('',(4.050000000093,126.2000000001)); +#6857 = CARTESIAN_POINT('',(4.050000000093,124.38134665216)); +#6858 = CARTESIAN_POINT('',(2.475000000093,125.29067332613)); +#6859 = CARTESIAN_POINT('',(0.900000000093,126.2000000001)); +#6860 = CARTESIAN_POINT('',(2.475000000093,127.10932667408)); +#6861 = CARTESIAN_POINT('',(4.050000000093,128.01865334805)); +#6862 = CARTESIAN_POINT('',(4.050000000093,126.2000000001)); +#6863 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6864 = PCURVE('',#4389,#6865); +#6865 = DEFINITIONAL_REPRESENTATION('',(#6866),#6870); +#6866 = LINE('',#6867,#6868); +#6867 = CARTESIAN_POINT('',(0.,0.)); +#6868 = VECTOR('',#6869,1.); +#6869 = DIRECTION('',(1.,0.)); +#6870 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6871 = FACE_BOUND('',#6872,.T.); +#6872 = EDGE_LOOP('',(#6873)); +#6873 = ORIENTED_EDGE('',*,*,#6874,.F.); +#6874 = EDGE_CURVE('',#6875,#6875,#6877,.T.); +#6875 = VERTEX_POINT('',#6876); +#6876 = CARTESIAN_POINT('',(-31.05000000016,-61.60000000002,38.5)); +#6877 = SURFACE_CURVE('',#6878,(#6883,#6894),.PCURVE_S1.); +#6878 = CIRCLE('',#6879,1.05); +#6879 = AXIS2_PLACEMENT_3D('',#6880,#6881,#6882); +#6880 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003,38.5)); +#6881 = DIRECTION('',(1.877684147211E-27,2.103154404859E-15,1.)); +#6882 = DIRECTION('',(1.,-2.878587004368E-12,4.176428790794E-27)); +#6883 = PCURVE('',#4811,#6884); +#6884 = DEFINITIONAL_REPRESENTATION('',(#6885),#6893); +#6885 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#6886,#6887,#6888,#6889, +#6890,#6891,#6892),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#6886 = CARTESIAN_POINT('',(57.950000000097,2.999999999994)); +#6887 = CARTESIAN_POINT('',(57.950000000095,4.818653347942)); +#6888 = CARTESIAN_POINT('',(59.525000000096,3.90932667397)); +#6889 = CARTESIAN_POINT('',(61.100000000097,2.999999999999)); +#6890 = CARTESIAN_POINT('',(59.525000000099,2.090673326023)); +#6891 = CARTESIAN_POINT('',(57.9500000001,1.181346652047)); +#6892 = CARTESIAN_POINT('',(57.950000000097,2.999999999994)); +#6893 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6894 = PCURVE('',#4358,#6895); +#6895 = DEFINITIONAL_REPRESENTATION('',(#6896),#6900); +#6896 = LINE('',#6897,#6898); +#6897 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#6898 = VECTOR('',#6899,1.); +#6899 = DIRECTION('',(1.,0.)); +#6900 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6901 = FACE_BOUND('',#6902,.T.); +#6902 = EDGE_LOOP('',(#6903)); +#6903 = ORIENTED_EDGE('',*,*,#6904,.T.); +#6904 = EDGE_CURVE('',#6905,#6905,#6907,.T.); +#6905 = VERTEX_POINT('',#6906); +#6906 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011,38.5)); +#6907 = SURFACE_CURVE('',#6908,(#6913,#6920),.PCURVE_S1.); +#6908 = CIRCLE('',#6909,1.05); +#6909 = AXIS2_PLACEMENT_3D('',#6910,#6911,#6912); +#6910 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,38.5)); +#6911 = DIRECTION('',(-1.487129577398E-27,-2.103154404859E-15,-1.)); +#6912 = DIRECTION('',(-1.,1.821208476878E-43,1.487129577398E-27)); +#6913 = PCURVE('',#4811,#6914); +#6914 = DEFINITIONAL_REPRESENTATION('',(#6915),#6919); +#6915 = CIRCLE('',#6916,1.05); +#6916 = AXIS2_PLACEMENT_2D('',#6917,#6918); +#6917 = CARTESIAN_POINT('',(3.000000000004,2.999999999996)); +#6918 = DIRECTION('',(1.,-1.439064838363E-12)); +#6919 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6920 = PCURVE('',#4327,#6921); +#6921 = DEFINITIONAL_REPRESENTATION('',(#6922),#6926); +#6922 = LINE('',#6923,#6924); +#6923 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#6924 = VECTOR('',#6925,1.); +#6925 = DIRECTION('',(1.,0.)); +#6926 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6927 = ADVANCED_FACE('',(#6928),#3419,.T.); +#6928 = FACE_BOUND('',#6929,.T.); +#6929 = EDGE_LOOP('',(#6930,#6931,#6952,#6953)); +#6930 = ORIENTED_EDGE('',*,*,#3402,.T.); +#6931 = ORIENTED_EDGE('',*,*,#6932,.T.); +#6932 = EDGE_CURVE('',#3375,#6083,#6933,.T.); +#6933 = SURFACE_CURVE('',#6934,(#6938,#6945),.PCURVE_S1.); +#6934 = LINE('',#6935,#6936); +#6935 = CARTESIAN_POINT('',(-30.00000000009,-64.60000000002, + 28.324999999994)); +#6936 = VECTOR('',#6937,1.); +#6937 = DIRECTION('',(-1.221646432603E-27,8.54607999747E-17,1.)); +#6938 = PCURVE('',#3419,#6939); +#6939 = DEFINITIONAL_REPRESENTATION('',(#6940),#6944); +#6940 = LINE('',#6941,#6942); +#6941 = CARTESIAN_POINT('',(5.497787143782,0.)); +#6942 = VECTOR('',#6943,1.); +#6943 = DIRECTION('',(0.,-1.)); +#6944 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6945 = PCURVE('',#3390,#6946); +#6946 = DEFINITIONAL_REPRESENTATION('',(#6947),#6951); +#6947 = LINE('',#6948,#6949); +#6948 = CARTESIAN_POINT('',(7.29999999999,10.175000000007)); +#6949 = VECTOR('',#6950,1.); +#6950 = DIRECTION('',(5.973360911024E-32,1.)); +#6951 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6952 = ORIENTED_EDGE('',*,*,#6082,.T.); +#6953 = ORIENTED_EDGE('',*,*,#6954,.T.); +#6954 = EDGE_CURVE('',#6060,#3403,#6955,.T.); +#6955 = SURFACE_CURVE('',#6956,(#6960,#6967),.PCURVE_S1.); +#6956 = LINE('',#6957,#6958); +#6957 = CARTESIAN_POINT('',(-33.00000000009,-61.60000000002, + 28.324999999994)); +#6958 = VECTOR('',#6959,1.); +#6959 = DIRECTION('',(1.221646432603E-27,-8.54607999747E-17,-1.)); +#6960 = PCURVE('',#3419,#6961); +#6961 = DEFINITIONAL_REPRESENTATION('',(#6962),#6966); +#6962 = LINE('',#6963,#6964); +#6963 = CARTESIAN_POINT('',(7.068583470577,0.)); +#6964 = VECTOR('',#6965,1.); +#6965 = DIRECTION('',(0.,1.)); +#6966 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6967 = PCURVE('',#3447,#6968); +#6968 = DEFINITIONAL_REPRESENTATION('',(#6969),#6973); +#6969 = LINE('',#6970,#6971); +#6970 = CARTESIAN_POINT('',(10.175000000007,3.)); +#6971 = VECTOR('',#6972,1.); +#6972 = DIRECTION('',(1.,2.612289469706E-16)); +#6973 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6974 = ADVANCED_FACE('',(#6975,#7001,#7082,#7196,#7282,#7396,#7505, + #7647,#7756,#7870,#8007,#8121,#8235),#3390,.F.); +#6975 = FACE_BOUND('',#6976,.T.); +#6976 = EDGE_LOOP('',(#6977,#6978,#6979,#7000)); +#6977 = ORIENTED_EDGE('',*,*,#6932,.F.); +#6978 = ORIENTED_EDGE('',*,*,#3374,.F.); +#6979 = ORIENTED_EDGE('',*,*,#6980,.F.); +#6980 = EDGE_CURVE('',#6107,#3346,#6981,.T.); +#6981 = SURFACE_CURVE('',#6982,(#6986,#6993),.PCURVE_S1.); +#6982 = LINE('',#6983,#6984); +#6983 = CARTESIAN_POINT('',(25.99999999993,-64.6000000001, + 11.324999999994)); +#6984 = VECTOR('',#6985,1.); +#6985 = DIRECTION('',(1.221646432603E-27,-8.54607999747E-17,-1.)); +#6986 = PCURVE('',#3390,#6987); +#6987 = DEFINITIONAL_REPRESENTATION('',(#6988),#6992); +#6988 = LINE('',#6989,#6990); +#6989 = CARTESIAN_POINT('',(-48.70000000003,-6.824999999993)); +#6990 = VECTOR('',#6991,1.); +#6991 = DIRECTION('',(-5.973360911024E-32,-1.)); +#6992 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#6993 = PCURVE('',#3362,#6994); +#6994 = DEFINITIONAL_REPRESENTATION('',(#6995),#6999); +#6995 = LINE('',#6996,#6997); +#6996 = CARTESIAN_POINT('',(7.068583470577,0.)); +#6997 = VECTOR('',#6998,1.); +#6998 = DIRECTION('',(6.530723674251E-18,1.)); +#6999 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7000 = ORIENTED_EDGE('',*,*,#6106,.F.); +#7001 = FACE_BOUND('',#7002,.T.); +#7002 = EDGE_LOOP('',(#7003,#7033,#7056)); +#7003 = ORIENTED_EDGE('',*,*,#7004,.F.); +#7004 = EDGE_CURVE('',#7005,#7007,#7009,.T.); +#7005 = VERTEX_POINT('',#7006); +#7006 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#7007 = VERTEX_POINT('',#7008); +#7008 = CARTESIAN_POINT('',(19.449999999882,-64.60000000009,31.5)); +#7009 = SURFACE_CURVE('',#7010,(#7014,#7021),.PCURVE_S1.); +#7010 = LINE('',#7011,#7012); +#7011 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7012 = VECTOR('',#7013,1.); +#7013 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7014 = PCURVE('',#3390,#7015); +#7015 = DEFINITIONAL_REPRESENTATION('',(#7016),#7020); +#7016 = LINE('',#7017,#7018); +#7017 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7018 = VECTOR('',#7019,1.); +#7019 = DIRECTION('',(1.,0.)); +#7020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7021 = PCURVE('',#7022,#7027); +#7022 = PLANE('',#7023); +#7023 = AXIS2_PLACEMENT_3D('',#7024,#7025,#7026); +#7024 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7025 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7026 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7027 = DEFINITIONAL_REPRESENTATION('',(#7028),#7032); +#7028 = LINE('',#7029,#7030); +#7029 = CARTESIAN_POINT('',(0.,0.)); +#7030 = VECTOR('',#7031,1.); +#7031 = DIRECTION('',(-1.,2.343516320473E-42)); +#7032 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7033 = ORIENTED_EDGE('',*,*,#7034,.F.); +#7034 = EDGE_CURVE('',#7035,#7005,#7037,.T.); +#7035 = VERTEX_POINT('',#7036); +#7036 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 28.949999999952)); +#7037 = SURFACE_CURVE('',#7038,(#7042,#7049),.PCURVE_S1.); +#7038 = LINE('',#7039,#7040); +#7039 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#7040 = VECTOR('',#7041,1.); +#7041 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7042 = PCURVE('',#3390,#7043); +#7043 = DEFINITIONAL_REPRESENTATION('',(#7044),#7048); +#7044 = LINE('',#7045,#7046); +#7045 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#7046 = VECTOR('',#7047,1.); +#7047 = DIRECTION('',(1.793662034336E-43,1.)); +#7048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7049 = PCURVE('',#3870,#7050); +#7050 = DEFINITIONAL_REPRESENTATION('',(#7051),#7055); +#7051 = LINE('',#7052,#7053); +#7052 = CARTESIAN_POINT('',(0.,0.)); +#7053 = VECTOR('',#7054,1.); +#7054 = DIRECTION('',(-1.,0.)); +#7055 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7056 = ORIENTED_EDGE('',*,*,#7057,.F.); +#7057 = EDGE_CURVE('',#7007,#7035,#7058,.T.); +#7058 = SURFACE_CURVE('',#7059,(#7063,#7070),.PCURVE_S1.); +#7059 = LINE('',#7060,#7061); +#7060 = CARTESIAN_POINT('',(19.149999999882,-64.60000000009,31.8)); +#7061 = VECTOR('',#7062,1.); +#7062 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7063 = PCURVE('',#3390,#7064); +#7064 = DEFINITIONAL_REPRESENTATION('',(#7065),#7069); +#7065 = LINE('',#7066,#7067); +#7066 = CARTESIAN_POINT('',(-41.84999999998,13.650000000013)); +#7067 = VECTOR('',#7068,1.); +#7068 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7069 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7070 = PCURVE('',#7071,#7076); +#7071 = PLANE('',#7072); +#7072 = AXIS2_PLACEMENT_3D('',#7073,#7074,#7075); +#7073 = CARTESIAN_POINT('',(44.449999999893,-64.60000000013, + 6.499999999988)); +#7074 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7075 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7076 = DEFINITIONAL_REPRESENTATION('',(#7077),#7081); +#7077 = LINE('',#7078,#7079); +#7078 = CARTESIAN_POINT('',(35.779603128055,-2.292788492775E-15)); +#7079 = VECTOR('',#7080,1.); +#7080 = DIRECTION('',(-1.,8.10752882526E-29)); +#7081 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7082 = FACE_BOUND('',#7083,.T.); +#7083 = EDGE_LOOP('',(#7084,#7114,#7142,#7170)); +#7084 = ORIENTED_EDGE('',*,*,#7085,.T.); +#7085 = EDGE_CURVE('',#7086,#7088,#7090,.T.); +#7086 = VERTEX_POINT('',#7087); +#7087 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 19.949999999979)); +#7088 = VERTEX_POINT('',#7089); +#7089 = CARTESIAN_POINT('',(-17.55000000011,-64.60000000004,11.5)); +#7090 = SURFACE_CURVE('',#7091,(#7095,#7102),.PCURVE_S1.); +#7091 = LINE('',#7092,#7093); +#7092 = CARTESIAN_POINT('',(-37.85000000011,-64.60000000001,31.8)); +#7093 = VECTOR('',#7094,1.); +#7094 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7095 = PCURVE('',#3390,#7096); +#7096 = DEFINITIONAL_REPRESENTATION('',(#7097),#7101); +#7097 = LINE('',#7098,#7099); +#7098 = CARTESIAN_POINT('',(15.150000000011,13.650000000013)); +#7099 = VECTOR('',#7100,1.); +#7100 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7101 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7102 = PCURVE('',#7103,#7108); +#7103 = PLANE('',#7104); +#7104 = AXIS2_PLACEMENT_3D('',#7105,#7106,#7107); +#7105 = CARTESIAN_POINT('',(-37.85000000011,-64.60000000001,31.8)); +#7106 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7107 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7108 = DEFINITIONAL_REPRESENTATION('',(#7109),#7113); +#7109 = LINE('',#7110,#7111); +#7110 = CARTESIAN_POINT('',(0.,0.)); +#7111 = VECTOR('',#7112,1.); +#7112 = DIRECTION('',(1.,1.854674126415E-29)); +#7113 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7114 = ORIENTED_EDGE('',*,*,#7115,.F.); +#7115 = EDGE_CURVE('',#7116,#7088,#7118,.T.); +#7116 = VERTEX_POINT('',#7117); +#7117 = CARTESIAN_POINT('',(-20.55000000011,-64.60000000004,11.5)); +#7118 = SURFACE_CURVE('',#7119,(#7123,#7130),.PCURVE_S1.); +#7119 = LINE('',#7120,#7121); +#7120 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7121 = VECTOR('',#7122,1.); +#7122 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7123 = PCURVE('',#3390,#7124); +#7124 = DEFINITIONAL_REPRESENTATION('',(#7125),#7129); +#7125 = LINE('',#7126,#7127); +#7126 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7127 = VECTOR('',#7128,1.); +#7128 = DIRECTION('',(-1.,0.)); +#7129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7130 = PCURVE('',#7131,#7136); +#7131 = PLANE('',#7132); +#7132 = AXIS2_PLACEMENT_3D('',#7133,#7134,#7135); +#7133 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7134 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7135 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7136 = DEFINITIONAL_REPRESENTATION('',(#7137),#7141); +#7137 = LINE('',#7138,#7139); +#7138 = CARTESIAN_POINT('',(0.,0.)); +#7139 = VECTOR('',#7140,1.); +#7140 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7141 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7142 = ORIENTED_EDGE('',*,*,#7143,.F.); +#7143 = EDGE_CURVE('',#7144,#7116,#7146,.T.); +#7144 = VERTEX_POINT('',#7145); +#7145 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 16.949999999979)); +#7146 = SURFACE_CURVE('',#7147,(#7151,#7158),.PCURVE_S1.); +#7147 = LINE('',#7148,#7149); +#7148 = CARTESIAN_POINT('',(-40.85000000011,-64.60000000001,31.8)); +#7149 = VECTOR('',#7150,1.); +#7150 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7151 = PCURVE('',#3390,#7152); +#7152 = DEFINITIONAL_REPRESENTATION('',(#7153),#7157); +#7153 = LINE('',#7154,#7155); +#7154 = CARTESIAN_POINT('',(18.150000000011,13.650000000013)); +#7155 = VECTOR('',#7156,1.); +#7156 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7157 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7158 = PCURVE('',#7159,#7164); +#7159 = PLANE('',#7160); +#7160 = AXIS2_PLACEMENT_3D('',#7161,#7162,#7163); +#7161 = CARTESIAN_POINT('',(-15.5500000001,-64.60000000004, + 6.499999999988)); +#7162 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7163 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7164 = DEFINITIONAL_REPRESENTATION('',(#7165),#7169); +#7165 = LINE('',#7166,#7167); +#7166 = CARTESIAN_POINT('',(35.779603128055,-2.29278849276E-15)); +#7167 = VECTOR('',#7168,1.); +#7168 = DIRECTION('',(-1.,8.10752882526E-29)); +#7169 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7170 = ORIENTED_EDGE('',*,*,#7171,.F.); +#7171 = EDGE_CURVE('',#7086,#7144,#7172,.T.); +#7172 = SURFACE_CURVE('',#7173,(#7177,#7184),.PCURVE_S1.); +#7173 = LINE('',#7174,#7175); +#7174 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7175 = VECTOR('',#7176,1.); +#7176 = DIRECTION('',(1.221586698994E-27,-8.54607999747E-17,-1.)); +#7177 = PCURVE('',#3390,#7178); +#7178 = DEFINITIONAL_REPRESENTATION('',(#7179),#7183); +#7179 = LINE('',#7180,#7181); +#7180 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#7181 = VECTOR('',#7182,1.); +#7182 = DIRECTION('',(-1.793662034336E-43,-1.)); +#7183 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7184 = PCURVE('',#7185,#7190); +#7185 = PLANE('',#7186); +#7186 = AXIS2_PLACEMENT_3D('',#7187,#7188,#7189); +#7187 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7188 = DIRECTION('',(-1.,1.439293502184E-12,-1.344589873089E-27)); +#7189 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7190 = DEFINITIONAL_REPRESENTATION('',(#7191),#7195); +#7191 = LINE('',#7192,#7193); +#7192 = CARTESIAN_POINT('',(-0.,0.)); +#7193 = VECTOR('',#7194,1.); +#7194 = DIRECTION('',(-1.,0.)); +#7195 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7196 = FACE_BOUND('',#7197,.T.); +#7197 = EDGE_LOOP('',(#7198,#7228,#7256)); +#7198 = ORIENTED_EDGE('',*,*,#7199,.T.); +#7199 = EDGE_CURVE('',#7200,#7202,#7204,.T.); +#7200 = VERTEX_POINT('',#7201); +#7201 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 13.949999999979)); +#7202 = VERTEX_POINT('',#7203); +#7203 = CARTESIAN_POINT('',(-23.55000000011,-64.60000000003,11.5)); +#7204 = SURFACE_CURVE('',#7205,(#7209,#7216),.PCURVE_S1.); +#7205 = LINE('',#7206,#7207); +#7206 = CARTESIAN_POINT('',(-43.85000000011,-64.6,31.8)); +#7207 = VECTOR('',#7208,1.); +#7208 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7209 = PCURVE('',#3390,#7210); +#7210 = DEFINITIONAL_REPRESENTATION('',(#7211),#7215); +#7211 = LINE('',#7212,#7213); +#7212 = CARTESIAN_POINT('',(21.150000000011,13.650000000013)); +#7213 = VECTOR('',#7214,1.); +#7214 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7215 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7216 = PCURVE('',#7217,#7222); +#7217 = PLANE('',#7218); +#7218 = AXIS2_PLACEMENT_3D('',#7219,#7220,#7221); +#7219 = CARTESIAN_POINT('',(-43.85000000011,-64.6,31.8)); +#7220 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7221 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7222 = DEFINITIONAL_REPRESENTATION('',(#7223),#7227); +#7223 = LINE('',#7224,#7225); +#7224 = CARTESIAN_POINT('',(0.,0.)); +#7225 = VECTOR('',#7226,1.); +#7226 = DIRECTION('',(1.,1.854674126415E-29)); +#7227 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7228 = ORIENTED_EDGE('',*,*,#7229,.F.); +#7229 = EDGE_CURVE('',#7230,#7202,#7232,.T.); +#7230 = VERTEX_POINT('',#7231); +#7231 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7232 = SURFACE_CURVE('',#7233,(#7237,#7244),.PCURVE_S1.); +#7233 = LINE('',#7234,#7235); +#7234 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7235 = VECTOR('',#7236,1.); +#7236 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7237 = PCURVE('',#3390,#7238); +#7238 = DEFINITIONAL_REPRESENTATION('',(#7239),#7243); +#7239 = LINE('',#7240,#7241); +#7240 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7241 = VECTOR('',#7242,1.); +#7242 = DIRECTION('',(-1.,0.)); +#7243 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7244 = PCURVE('',#7245,#7250); +#7245 = PLANE('',#7246); +#7246 = AXIS2_PLACEMENT_3D('',#7247,#7248,#7249); +#7247 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7248 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7249 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7250 = DEFINITIONAL_REPRESENTATION('',(#7251),#7255); +#7251 = LINE('',#7252,#7253); +#7252 = CARTESIAN_POINT('',(0.,0.)); +#7253 = VECTOR('',#7254,1.); +#7254 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7255 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7256 = ORIENTED_EDGE('',*,*,#7257,.F.); +#7257 = EDGE_CURVE('',#7200,#7230,#7258,.T.); +#7258 = SURFACE_CURVE('',#7259,(#7263,#7270),.PCURVE_S1.); +#7259 = LINE('',#7260,#7261); +#7260 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7261 = VECTOR('',#7262,1.); +#7262 = DIRECTION('',(1.221586698994E-27,-8.54607999747E-17,-1.)); +#7263 = PCURVE('',#3390,#7264); +#7264 = DEFINITIONAL_REPRESENTATION('',(#7265),#7269); +#7265 = LINE('',#7266,#7267); +#7266 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#7267 = VECTOR('',#7268,1.); +#7268 = DIRECTION('',(-1.793662034336E-43,-1.)); +#7269 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7270 = PCURVE('',#7271,#7276); +#7271 = PLANE('',#7272); +#7272 = AXIS2_PLACEMENT_3D('',#7273,#7274,#7275); +#7273 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7274 = DIRECTION('',(-1.,1.439293502184E-12,-1.344589873089E-27)); +#7275 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7276 = DEFINITIONAL_REPRESENTATION('',(#7277),#7281); +#7277 = LINE('',#7278,#7279); +#7278 = CARTESIAN_POINT('',(-0.,0.)); +#7279 = VECTOR('',#7280,1.); +#7280 = DIRECTION('',(-1.,0.)); +#7281 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7282 = FACE_BOUND('',#7283,.T.); +#7283 = EDGE_LOOP('',(#7284,#7314,#7342,#7370)); +#7284 = ORIENTED_EDGE('',*,*,#7285,.T.); +#7285 = EDGE_CURVE('',#7286,#7288,#7290,.T.); +#7286 = VERTEX_POINT('',#7287); +#7287 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 25.949999999979)); +#7288 = VERTEX_POINT('',#7289); +#7289 = CARTESIAN_POINT('',(-11.55000000011,-64.60000000005,11.5)); +#7290 = SURFACE_CURVE('',#7291,(#7295,#7302),.PCURVE_S1.); +#7291 = LINE('',#7292,#7293); +#7292 = CARTESIAN_POINT('',(-31.85000000011,-64.60000000002,31.8)); +#7293 = VECTOR('',#7294,1.); +#7294 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7295 = PCURVE('',#3390,#7296); +#7296 = DEFINITIONAL_REPRESENTATION('',(#7297),#7301); +#7297 = LINE('',#7298,#7299); +#7298 = CARTESIAN_POINT('',(9.150000000011,13.650000000013)); +#7299 = VECTOR('',#7300,1.); +#7300 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7301 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7302 = PCURVE('',#7303,#7308); +#7303 = PLANE('',#7304); +#7304 = AXIS2_PLACEMENT_3D('',#7305,#7306,#7307); +#7305 = CARTESIAN_POINT('',(-31.85000000011,-64.60000000002,31.8)); +#7306 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7307 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7308 = DEFINITIONAL_REPRESENTATION('',(#7309),#7313); +#7309 = LINE('',#7310,#7311); +#7310 = CARTESIAN_POINT('',(0.,0.)); +#7311 = VECTOR('',#7312,1.); +#7312 = DIRECTION('',(1.,1.854674126415E-29)); +#7313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7314 = ORIENTED_EDGE('',*,*,#7315,.F.); +#7315 = EDGE_CURVE('',#7316,#7288,#7318,.T.); +#7316 = VERTEX_POINT('',#7317); +#7317 = CARTESIAN_POINT('',(-14.55000000011,-64.60000000005,11.5)); +#7318 = SURFACE_CURVE('',#7319,(#7323,#7330),.PCURVE_S1.); +#7319 = LINE('',#7320,#7321); +#7320 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7321 = VECTOR('',#7322,1.); +#7322 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7323 = PCURVE('',#3390,#7324); +#7324 = DEFINITIONAL_REPRESENTATION('',(#7325),#7329); +#7325 = LINE('',#7326,#7327); +#7326 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7327 = VECTOR('',#7328,1.); +#7328 = DIRECTION('',(-1.,0.)); +#7329 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7330 = PCURVE('',#7331,#7336); +#7331 = PLANE('',#7332); +#7332 = AXIS2_PLACEMENT_3D('',#7333,#7334,#7335); +#7333 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7334 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7335 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7336 = DEFINITIONAL_REPRESENTATION('',(#7337),#7341); +#7337 = LINE('',#7338,#7339); +#7338 = CARTESIAN_POINT('',(0.,0.)); +#7339 = VECTOR('',#7340,1.); +#7340 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7341 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7342 = ORIENTED_EDGE('',*,*,#7343,.F.); +#7343 = EDGE_CURVE('',#7344,#7316,#7346,.T.); +#7344 = VERTEX_POINT('',#7345); +#7345 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 22.949999999979)); +#7346 = SURFACE_CURVE('',#7347,(#7351,#7358),.PCURVE_S1.); +#7347 = LINE('',#7348,#7349); +#7348 = CARTESIAN_POINT('',(-34.85000000011,-64.60000000002,31.8)); +#7349 = VECTOR('',#7350,1.); +#7350 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7351 = PCURVE('',#3390,#7352); +#7352 = DEFINITIONAL_REPRESENTATION('',(#7353),#7357); +#7353 = LINE('',#7354,#7355); +#7354 = CARTESIAN_POINT('',(12.150000000011,13.650000000013)); +#7355 = VECTOR('',#7356,1.); +#7356 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7358 = PCURVE('',#7359,#7364); +#7359 = PLANE('',#7360); +#7360 = AXIS2_PLACEMENT_3D('',#7361,#7362,#7363); +#7361 = CARTESIAN_POINT('',(-9.550000000107,-64.60000000005, + 6.499999999988)); +#7362 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7363 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7364 = DEFINITIONAL_REPRESENTATION('',(#7365),#7369); +#7365 = LINE('',#7366,#7367); +#7366 = CARTESIAN_POINT('',(35.779603128055,-2.292788492765E-15)); +#7367 = VECTOR('',#7368,1.); +#7368 = DIRECTION('',(-1.,8.10752882526E-29)); +#7369 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7370 = ORIENTED_EDGE('',*,*,#7371,.F.); +#7371 = EDGE_CURVE('',#7286,#7344,#7372,.T.); +#7372 = SURFACE_CURVE('',#7373,(#7377,#7384),.PCURVE_S1.); +#7373 = LINE('',#7374,#7375); +#7374 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7375 = VECTOR('',#7376,1.); +#7376 = DIRECTION('',(1.221586698994E-27,-8.54607999747E-17,-1.)); +#7377 = PCURVE('',#3390,#7378); +#7378 = DEFINITIONAL_REPRESENTATION('',(#7379),#7383); +#7379 = LINE('',#7380,#7381); +#7380 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#7381 = VECTOR('',#7382,1.); +#7382 = DIRECTION('',(-1.793662034336E-43,-1.)); +#7383 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7384 = PCURVE('',#7385,#7390); +#7385 = PLANE('',#7386); +#7386 = AXIS2_PLACEMENT_3D('',#7387,#7388,#7389); +#7387 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7388 = DIRECTION('',(-1.,1.439293502184E-12,-1.344589873089E-27)); +#7389 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7390 = DEFINITIONAL_REPRESENTATION('',(#7391),#7395); +#7391 = LINE('',#7392,#7393); +#7392 = CARTESIAN_POINT('',(-0.,0.)); +#7393 = VECTOR('',#7394,1.); +#7394 = DIRECTION('',(-1.,0.)); +#7395 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7396 = FACE_BOUND('',#7397,.T.); +#7397 = EDGE_LOOP('',(#7398,#7428,#7456,#7479)); +#7398 = ORIENTED_EDGE('',*,*,#7399,.F.); +#7399 = EDGE_CURVE('',#7400,#7402,#7404,.T.); +#7400 = VERTEX_POINT('',#7401); +#7401 = CARTESIAN_POINT('',(16.449999999882,-64.60000000009,31.5)); +#7402 = VERTEX_POINT('',#7403); +#7403 = CARTESIAN_POINT('',(13.449999999882,-64.60000000009,31.5)); +#7404 = SURFACE_CURVE('',#7405,(#7409,#7416),.PCURVE_S1.); +#7405 = LINE('',#7406,#7407); +#7406 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7407 = VECTOR('',#7408,1.); +#7408 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7409 = PCURVE('',#3390,#7410); +#7410 = DEFINITIONAL_REPRESENTATION('',(#7411),#7415); +#7411 = LINE('',#7412,#7413); +#7412 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7413 = VECTOR('',#7414,1.); +#7414 = DIRECTION('',(1.,0.)); +#7415 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7416 = PCURVE('',#7417,#7422); +#7417 = PLANE('',#7418); +#7418 = AXIS2_PLACEMENT_3D('',#7419,#7420,#7421); +#7419 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7420 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7421 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7422 = DEFINITIONAL_REPRESENTATION('',(#7423),#7427); +#7423 = LINE('',#7424,#7425); +#7424 = CARTESIAN_POINT('',(0.,0.)); +#7425 = VECTOR('',#7426,1.); +#7426 = DIRECTION('',(-1.,2.343516320473E-42)); +#7427 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7428 = ORIENTED_EDGE('',*,*,#7429,.T.); +#7429 = EDGE_CURVE('',#7400,#7430,#7432,.T.); +#7430 = VERTEX_POINT('',#7431); +#7431 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 25.949999999952)); +#7432 = SURFACE_CURVE('',#7433,(#7437,#7444),.PCURVE_S1.); +#7433 = LINE('',#7434,#7435); +#7434 = CARTESIAN_POINT('',(16.149999999882,-64.60000000009,31.8)); +#7435 = VECTOR('',#7436,1.); +#7436 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7437 = PCURVE('',#3390,#7438); +#7438 = DEFINITIONAL_REPRESENTATION('',(#7439),#7443); +#7439 = LINE('',#7440,#7441); +#7440 = CARTESIAN_POINT('',(-38.84999999998,13.650000000013)); +#7441 = VECTOR('',#7442,1.); +#7442 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7443 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7444 = PCURVE('',#7445,#7450); +#7445 = PLANE('',#7446); +#7446 = AXIS2_PLACEMENT_3D('',#7447,#7448,#7449); +#7447 = CARTESIAN_POINT('',(16.149999999882,-64.60000000009,31.8)); +#7448 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7449 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7450 = DEFINITIONAL_REPRESENTATION('',(#7451),#7455); +#7451 = LINE('',#7452,#7453); +#7452 = CARTESIAN_POINT('',(0.,0.)); +#7453 = VECTOR('',#7454,1.); +#7454 = DIRECTION('',(1.,1.854674126415E-29)); +#7455 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7456 = ORIENTED_EDGE('',*,*,#7457,.F.); +#7457 = EDGE_CURVE('',#7458,#7430,#7460,.T.); +#7458 = VERTEX_POINT('',#7459); +#7459 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 22.949999999952)); +#7460 = SURFACE_CURVE('',#7461,(#7465,#7472),.PCURVE_S1.); +#7461 = LINE('',#7462,#7463); +#7462 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#7463 = VECTOR('',#7464,1.); +#7464 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7465 = PCURVE('',#3390,#7466); +#7466 = DEFINITIONAL_REPRESENTATION('',(#7467),#7471); +#7467 = LINE('',#7468,#7469); +#7468 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#7469 = VECTOR('',#7470,1.); +#7470 = DIRECTION('',(1.793662034336E-43,1.)); +#7471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7472 = PCURVE('',#3870,#7473); +#7473 = DEFINITIONAL_REPRESENTATION('',(#7474),#7478); +#7474 = LINE('',#7475,#7476); +#7475 = CARTESIAN_POINT('',(0.,0.)); +#7476 = VECTOR('',#7477,1.); +#7477 = DIRECTION('',(-1.,0.)); +#7478 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7479 = ORIENTED_EDGE('',*,*,#7480,.F.); +#7480 = EDGE_CURVE('',#7402,#7458,#7481,.T.); +#7481 = SURFACE_CURVE('',#7482,(#7486,#7493),.PCURVE_S1.); +#7482 = LINE('',#7483,#7484); +#7483 = CARTESIAN_POINT('',(13.149999999882,-64.60000000009,31.8)); +#7484 = VECTOR('',#7485,1.); +#7485 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7486 = PCURVE('',#3390,#7487); +#7487 = DEFINITIONAL_REPRESENTATION('',(#7488),#7492); +#7488 = LINE('',#7489,#7490); +#7489 = CARTESIAN_POINT('',(-35.84999999998,13.650000000013)); +#7490 = VECTOR('',#7491,1.); +#7491 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7493 = PCURVE('',#7494,#7499); +#7494 = PLANE('',#7495); +#7495 = AXIS2_PLACEMENT_3D('',#7496,#7497,#7498); +#7496 = CARTESIAN_POINT('',(38.449999999893,-64.60000000012, + 6.499999999988)); +#7497 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7498 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7499 = DEFINITIONAL_REPRESENTATION('',(#7500),#7504); +#7500 = LINE('',#7501,#7502); +#7501 = CARTESIAN_POINT('',(35.779603128055,1.191806622243E-14)); +#7502 = VECTOR('',#7503,1.); +#7503 = DIRECTION('',(-1.,8.10752882526E-29)); +#7504 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7505 = FACE_BOUND('',#7506,.T.); +#7506 = EDGE_LOOP('',(#7507,#7537,#7565,#7593,#7621)); +#7507 = ORIENTED_EDGE('',*,*,#7508,.T.); +#7508 = EDGE_CURVE('',#7509,#7511,#7513,.T.); +#7509 = VERTEX_POINT('',#7510); +#7510 = CARTESIAN_POINT('',(-25.55000000011,-64.60000000003,31.5)); +#7511 = VERTEX_POINT('',#7512); +#7512 = CARTESIAN_POINT('',(-5.550000000118,-64.60000000006,11.5)); +#7513 = SURFACE_CURVE('',#7514,(#7518,#7525),.PCURVE_S1.); +#7514 = LINE('',#7515,#7516); +#7515 = CARTESIAN_POINT('',(-25.85000000011,-64.60000000003,31.8)); +#7516 = VECTOR('',#7517,1.); +#7517 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7518 = PCURVE('',#3390,#7519); +#7519 = DEFINITIONAL_REPRESENTATION('',(#7520),#7524); +#7520 = LINE('',#7521,#7522); +#7521 = CARTESIAN_POINT('',(3.150000000011,13.650000000013)); +#7522 = VECTOR('',#7523,1.); +#7523 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7524 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7525 = PCURVE('',#7526,#7531); +#7526 = PLANE('',#7527); +#7527 = AXIS2_PLACEMENT_3D('',#7528,#7529,#7530); +#7528 = CARTESIAN_POINT('',(-25.85000000011,-64.60000000003,31.8)); +#7529 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7530 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7531 = DEFINITIONAL_REPRESENTATION('',(#7532),#7536); +#7532 = LINE('',#7533,#7534); +#7533 = CARTESIAN_POINT('',(0.,0.)); +#7534 = VECTOR('',#7535,1.); +#7535 = DIRECTION('',(1.,1.854674126415E-29)); +#7536 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7537 = ORIENTED_EDGE('',*,*,#7538,.F.); +#7538 = EDGE_CURVE('',#7539,#7511,#7541,.T.); +#7539 = VERTEX_POINT('',#7540); +#7540 = CARTESIAN_POINT('',(-8.550000000119,-64.60000000005,11.5)); +#7541 = SURFACE_CURVE('',#7542,(#7546,#7553),.PCURVE_S1.); +#7542 = LINE('',#7543,#7544); +#7543 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7544 = VECTOR('',#7545,1.); +#7545 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7546 = PCURVE('',#3390,#7547); +#7547 = DEFINITIONAL_REPRESENTATION('',(#7548),#7552); +#7548 = LINE('',#7549,#7550); +#7549 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7550 = VECTOR('',#7551,1.); +#7551 = DIRECTION('',(-1.,0.)); +#7552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7553 = PCURVE('',#7554,#7559); +#7554 = PLANE('',#7555); +#7555 = AXIS2_PLACEMENT_3D('',#7556,#7557,#7558); +#7556 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7557 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7558 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7559 = DEFINITIONAL_REPRESENTATION('',(#7560),#7564); +#7560 = LINE('',#7561,#7562); +#7561 = CARTESIAN_POINT('',(0.,0.)); +#7562 = VECTOR('',#7563,1.); +#7563 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7564 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7565 = ORIENTED_EDGE('',*,*,#7566,.F.); +#7566 = EDGE_CURVE('',#7567,#7539,#7569,.T.); +#7567 = VERTEX_POINT('',#7568); +#7568 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 28.949999999979)); +#7569 = SURFACE_CURVE('',#7570,(#7574,#7581),.PCURVE_S1.); +#7570 = LINE('',#7571,#7572); +#7571 = CARTESIAN_POINT('',(-28.85000000011,-64.60000000003,31.8)); +#7572 = VECTOR('',#7573,1.); +#7573 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7574 = PCURVE('',#3390,#7575); +#7575 = DEFINITIONAL_REPRESENTATION('',(#7576),#7580); +#7576 = LINE('',#7577,#7578); +#7577 = CARTESIAN_POINT('',(6.150000000011,13.650000000013)); +#7578 = VECTOR('',#7579,1.); +#7579 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7581 = PCURVE('',#7582,#7587); +#7582 = PLANE('',#7583); +#7583 = AXIS2_PLACEMENT_3D('',#7584,#7585,#7586); +#7584 = CARTESIAN_POINT('',(-3.550000000107,-64.60000000006, + 6.499999999988)); +#7585 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7586 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7587 = DEFINITIONAL_REPRESENTATION('',(#7588),#7592); +#7588 = LINE('',#7589,#7590); +#7589 = CARTESIAN_POINT('',(35.779603128055,1.113940492289E-13)); +#7590 = VECTOR('',#7591,1.); +#7591 = DIRECTION('',(-1.,8.10752882526E-29)); +#7592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7593 = ORIENTED_EDGE('',*,*,#7594,.F.); +#7594 = EDGE_CURVE('',#7595,#7567,#7597,.T.); +#7595 = VERTEX_POINT('',#7596); +#7596 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7597 = SURFACE_CURVE('',#7598,(#7602,#7609),.PCURVE_S1.); +#7598 = LINE('',#7599,#7600); +#7599 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7600 = VECTOR('',#7601,1.); +#7601 = DIRECTION('',(1.221586698994E-27,-8.54607999747E-17,-1.)); +#7602 = PCURVE('',#3390,#7603); +#7603 = DEFINITIONAL_REPRESENTATION('',(#7604),#7608); +#7604 = LINE('',#7605,#7606); +#7605 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#7606 = VECTOR('',#7607,1.); +#7607 = DIRECTION('',(-1.793662034336E-43,-1.)); +#7608 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7609 = PCURVE('',#7610,#7615); +#7610 = PLANE('',#7611); +#7611 = AXIS2_PLACEMENT_3D('',#7612,#7613,#7614); +#7612 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#7613 = DIRECTION('',(-1.,1.439293502184E-12,-1.344589873089E-27)); +#7614 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7615 = DEFINITIONAL_REPRESENTATION('',(#7616),#7620); +#7616 = LINE('',#7617,#7618); +#7617 = CARTESIAN_POINT('',(-0.,0.)); +#7618 = VECTOR('',#7619,1.); +#7619 = DIRECTION('',(-1.,0.)); +#7620 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7621 = ORIENTED_EDGE('',*,*,#7622,.F.); +#7622 = EDGE_CURVE('',#7509,#7595,#7623,.T.); +#7623 = SURFACE_CURVE('',#7624,(#7628,#7635),.PCURVE_S1.); +#7624 = LINE('',#7625,#7626); +#7625 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7626 = VECTOR('',#7627,1.); +#7627 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7628 = PCURVE('',#3390,#7629); +#7629 = DEFINITIONAL_REPRESENTATION('',(#7630),#7634); +#7630 = LINE('',#7631,#7632); +#7631 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7632 = VECTOR('',#7633,1.); +#7633 = DIRECTION('',(1.,0.)); +#7634 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7635 = PCURVE('',#7636,#7641); +#7636 = PLANE('',#7637); +#7637 = AXIS2_PLACEMENT_3D('',#7638,#7639,#7640); +#7638 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7639 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7640 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7641 = DEFINITIONAL_REPRESENTATION('',(#7642),#7646); +#7642 = LINE('',#7643,#7644); +#7643 = CARTESIAN_POINT('',(0.,0.)); +#7644 = VECTOR('',#7645,1.); +#7645 = DIRECTION('',(-1.,2.343516320473E-42)); +#7646 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7647 = FACE_BOUND('',#7648,.T.); +#7648 = EDGE_LOOP('',(#7649,#7679,#7707,#7730)); +#7649 = ORIENTED_EDGE('',*,*,#7650,.F.); +#7650 = EDGE_CURVE('',#7651,#7653,#7655,.T.); +#7651 = VERTEX_POINT('',#7652); +#7652 = CARTESIAN_POINT('',(10.449999999882,-64.60000000008,31.5)); +#7653 = VERTEX_POINT('',#7654); +#7654 = CARTESIAN_POINT('',(7.449999999882,-64.60000000008,31.5)); +#7655 = SURFACE_CURVE('',#7656,(#7660,#7667),.PCURVE_S1.); +#7656 = LINE('',#7657,#7658); +#7657 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7658 = VECTOR('',#7659,1.); +#7659 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7660 = PCURVE('',#3390,#7661); +#7661 = DEFINITIONAL_REPRESENTATION('',(#7662),#7666); +#7662 = LINE('',#7663,#7664); +#7663 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7664 = VECTOR('',#7665,1.); +#7665 = DIRECTION('',(1.,0.)); +#7666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7667 = PCURVE('',#7668,#7673); +#7668 = PLANE('',#7669); +#7669 = AXIS2_PLACEMENT_3D('',#7670,#7671,#7672); +#7670 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7671 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7672 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7673 = DEFINITIONAL_REPRESENTATION('',(#7674),#7678); +#7674 = LINE('',#7675,#7676); +#7675 = CARTESIAN_POINT('',(0.,0.)); +#7676 = VECTOR('',#7677,1.); +#7677 = DIRECTION('',(-1.,2.343516320473E-42)); +#7678 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7679 = ORIENTED_EDGE('',*,*,#7680,.T.); +#7680 = EDGE_CURVE('',#7651,#7681,#7683,.T.); +#7681 = VERTEX_POINT('',#7682); +#7682 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 19.949999999952)); +#7683 = SURFACE_CURVE('',#7684,(#7688,#7695),.PCURVE_S1.); +#7684 = LINE('',#7685,#7686); +#7685 = CARTESIAN_POINT('',(10.149999999882,-64.60000000008,31.8)); +#7686 = VECTOR('',#7687,1.); +#7687 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7688 = PCURVE('',#3390,#7689); +#7689 = DEFINITIONAL_REPRESENTATION('',(#7690),#7694); +#7690 = LINE('',#7691,#7692); +#7691 = CARTESIAN_POINT('',(-32.84999999998,13.650000000013)); +#7692 = VECTOR('',#7693,1.); +#7693 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7694 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7695 = PCURVE('',#7696,#7701); +#7696 = PLANE('',#7697); +#7697 = AXIS2_PLACEMENT_3D('',#7698,#7699,#7700); +#7698 = CARTESIAN_POINT('',(10.149999999882,-64.60000000008,31.8)); +#7699 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7700 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7701 = DEFINITIONAL_REPRESENTATION('',(#7702),#7706); +#7702 = LINE('',#7703,#7704); +#7703 = CARTESIAN_POINT('',(0.,0.)); +#7704 = VECTOR('',#7705,1.); +#7705 = DIRECTION('',(1.,1.854674126415E-29)); +#7706 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7707 = ORIENTED_EDGE('',*,*,#7708,.F.); +#7708 = EDGE_CURVE('',#7709,#7681,#7711,.T.); +#7709 = VERTEX_POINT('',#7710); +#7710 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 16.949999999952)); +#7711 = SURFACE_CURVE('',#7712,(#7716,#7723),.PCURVE_S1.); +#7712 = LINE('',#7713,#7714); +#7713 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#7714 = VECTOR('',#7715,1.); +#7715 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7716 = PCURVE('',#3390,#7717); +#7717 = DEFINITIONAL_REPRESENTATION('',(#7718),#7722); +#7718 = LINE('',#7719,#7720); +#7719 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#7720 = VECTOR('',#7721,1.); +#7721 = DIRECTION('',(1.793662034336E-43,1.)); +#7722 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7723 = PCURVE('',#3870,#7724); +#7724 = DEFINITIONAL_REPRESENTATION('',(#7725),#7729); +#7725 = LINE('',#7726,#7727); +#7726 = CARTESIAN_POINT('',(0.,0.)); +#7727 = VECTOR('',#7728,1.); +#7728 = DIRECTION('',(-1.,0.)); +#7729 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7730 = ORIENTED_EDGE('',*,*,#7731,.F.); +#7731 = EDGE_CURVE('',#7653,#7709,#7732,.T.); +#7732 = SURFACE_CURVE('',#7733,(#7737,#7744),.PCURVE_S1.); +#7733 = LINE('',#7734,#7735); +#7734 = CARTESIAN_POINT('',(7.149999999882,-64.60000000008,31.8)); +#7735 = VECTOR('',#7736,1.); +#7736 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7737 = PCURVE('',#3390,#7738); +#7738 = DEFINITIONAL_REPRESENTATION('',(#7739),#7743); +#7739 = LINE('',#7740,#7741); +#7740 = CARTESIAN_POINT('',(-29.84999999998,13.650000000013)); +#7741 = VECTOR('',#7742,1.); +#7742 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7743 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7744 = PCURVE('',#7745,#7750); +#7745 = PLANE('',#7746); +#7746 = AXIS2_PLACEMENT_3D('',#7747,#7748,#7749); +#7747 = CARTESIAN_POINT('',(32.449999999893,-64.60000000011, + 6.499999999988)); +#7748 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7749 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7750 = DEFINITIONAL_REPRESENTATION('',(#7751),#7755); +#7751 = LINE('',#7752,#7753); +#7752 = CARTESIAN_POINT('',(35.779603128055,1.191806622243E-14)); +#7753 = VECTOR('',#7754,1.); +#7754 = DIRECTION('',(-1.,8.10752882526E-29)); +#7755 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7756 = FACE_BOUND('',#7757,.T.); +#7757 = EDGE_LOOP('',(#7758,#7788,#7816,#7844)); +#7758 = ORIENTED_EDGE('',*,*,#7759,.T.); +#7759 = EDGE_CURVE('',#7760,#7762,#7764,.T.); +#7760 = VERTEX_POINT('',#7761); +#7761 = CARTESIAN_POINT('',(-19.55000000011,-64.60000000004,31.5)); +#7762 = VERTEX_POINT('',#7763); +#7763 = CARTESIAN_POINT('',(0.449999999882,-64.60000000007,11.5)); +#7764 = SURFACE_CURVE('',#7765,(#7769,#7776),.PCURVE_S1.); +#7765 = LINE('',#7766,#7767); +#7766 = CARTESIAN_POINT('',(-19.85000000011,-64.60000000004,31.8)); +#7767 = VECTOR('',#7768,1.); +#7768 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7769 = PCURVE('',#3390,#7770); +#7770 = DEFINITIONAL_REPRESENTATION('',(#7771),#7775); +#7771 = LINE('',#7772,#7773); +#7772 = CARTESIAN_POINT('',(-2.849999999989,13.650000000013)); +#7773 = VECTOR('',#7774,1.); +#7774 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7775 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7776 = PCURVE('',#7777,#7782); +#7777 = PLANE('',#7778); +#7778 = AXIS2_PLACEMENT_3D('',#7779,#7780,#7781); +#7779 = CARTESIAN_POINT('',(-19.85000000011,-64.60000000004,31.8)); +#7780 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7781 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7782 = DEFINITIONAL_REPRESENTATION('',(#7783),#7787); +#7783 = LINE('',#7784,#7785); +#7784 = CARTESIAN_POINT('',(0.,0.)); +#7785 = VECTOR('',#7786,1.); +#7786 = DIRECTION('',(1.,1.854674126415E-29)); +#7787 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7788 = ORIENTED_EDGE('',*,*,#7789,.F.); +#7789 = EDGE_CURVE('',#7790,#7762,#7792,.T.); +#7790 = VERTEX_POINT('',#7791); +#7791 = CARTESIAN_POINT('',(-2.550000000118,-64.60000000006,11.5)); +#7792 = SURFACE_CURVE('',#7793,(#7797,#7804),.PCURVE_S1.); +#7793 = LINE('',#7794,#7795); +#7794 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7795 = VECTOR('',#7796,1.); +#7796 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7797 = PCURVE('',#3390,#7798); +#7798 = DEFINITIONAL_REPRESENTATION('',(#7799),#7803); +#7799 = LINE('',#7800,#7801); +#7800 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7801 = VECTOR('',#7802,1.); +#7802 = DIRECTION('',(-1.,0.)); +#7803 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7804 = PCURVE('',#7805,#7810); +#7805 = PLANE('',#7806); +#7806 = AXIS2_PLACEMENT_3D('',#7807,#7808,#7809); +#7807 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7808 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7809 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7810 = DEFINITIONAL_REPRESENTATION('',(#7811),#7815); +#7811 = LINE('',#7812,#7813); +#7812 = CARTESIAN_POINT('',(0.,0.)); +#7813 = VECTOR('',#7814,1.); +#7814 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7815 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7816 = ORIENTED_EDGE('',*,*,#7817,.F.); +#7817 = EDGE_CURVE('',#7818,#7790,#7820,.T.); +#7818 = VERTEX_POINT('',#7819); +#7819 = CARTESIAN_POINT('',(-22.55000000011,-64.60000000003,31.5)); +#7820 = SURFACE_CURVE('',#7821,(#7825,#7832),.PCURVE_S1.); +#7821 = LINE('',#7822,#7823); +#7822 = CARTESIAN_POINT('',(-22.85000000011,-64.60000000003,31.8)); +#7823 = VECTOR('',#7824,1.); +#7824 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7825 = PCURVE('',#3390,#7826); +#7826 = DEFINITIONAL_REPRESENTATION('',(#7827),#7831); +#7827 = LINE('',#7828,#7829); +#7828 = CARTESIAN_POINT('',(0.150000000011,13.650000000013)); +#7829 = VECTOR('',#7830,1.); +#7830 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7831 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7832 = PCURVE('',#7833,#7838); +#7833 = PLANE('',#7834); +#7834 = AXIS2_PLACEMENT_3D('',#7835,#7836,#7837); +#7835 = CARTESIAN_POINT('',(2.449999999893,-64.60000000007, + 6.499999999988)); +#7836 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#7837 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#7838 = DEFINITIONAL_REPRESENTATION('',(#7839),#7843); +#7839 = LINE('',#7840,#7841); +#7840 = CARTESIAN_POINT('',(35.779603128055,1.191806622244E-14)); +#7841 = VECTOR('',#7842,1.); +#7842 = DIRECTION('',(-1.,8.10752882526E-29)); +#7843 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7844 = ORIENTED_EDGE('',*,*,#7845,.F.); +#7845 = EDGE_CURVE('',#7760,#7818,#7846,.T.); +#7846 = SURFACE_CURVE('',#7847,(#7851,#7858),.PCURVE_S1.); +#7847 = LINE('',#7848,#7849); +#7848 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7849 = VECTOR('',#7850,1.); +#7850 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7851 = PCURVE('',#3390,#7852); +#7852 = DEFINITIONAL_REPRESENTATION('',(#7853),#7857); +#7853 = LINE('',#7854,#7855); +#7854 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7855 = VECTOR('',#7856,1.); +#7856 = DIRECTION('',(1.,0.)); +#7857 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7858 = PCURVE('',#7859,#7864); +#7859 = PLANE('',#7860); +#7860 = AXIS2_PLACEMENT_3D('',#7861,#7862,#7863); +#7861 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7862 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7863 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7864 = DEFINITIONAL_REPRESENTATION('',(#7865),#7869); +#7865 = LINE('',#7866,#7867); +#7866 = CARTESIAN_POINT('',(0.,0.)); +#7867 = VECTOR('',#7868,1.); +#7868 = DIRECTION('',(-1.,2.343516320473E-42)); +#7869 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7870 = FACE_BOUND('',#7871,.T.); +#7871 = EDGE_LOOP('',(#7872,#7902,#7930,#7953,#7981)); +#7872 = ORIENTED_EDGE('',*,*,#7873,.F.); +#7873 = EDGE_CURVE('',#7874,#7876,#7878,.T.); +#7874 = VERTEX_POINT('',#7875); +#7875 = CARTESIAN_POINT('',(4.449999999882,-64.60000000007,31.5)); +#7876 = VERTEX_POINT('',#7877); +#7877 = CARTESIAN_POINT('',(1.449999999882,-64.60000000007,31.5)); +#7878 = SURFACE_CURVE('',#7879,(#7883,#7890),.PCURVE_S1.); +#7879 = LINE('',#7880,#7881); +#7880 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7881 = VECTOR('',#7882,1.); +#7882 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7883 = PCURVE('',#3390,#7884); +#7884 = DEFINITIONAL_REPRESENTATION('',(#7885),#7889); +#7885 = LINE('',#7886,#7887); +#7886 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#7887 = VECTOR('',#7888,1.); +#7888 = DIRECTION('',(1.,0.)); +#7889 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7890 = PCURVE('',#7891,#7896); +#7891 = PLANE('',#7892); +#7892 = AXIS2_PLACEMENT_3D('',#7893,#7894,#7895); +#7893 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#7894 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#7895 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7896 = DEFINITIONAL_REPRESENTATION('',(#7897),#7901); +#7897 = LINE('',#7898,#7899); +#7898 = CARTESIAN_POINT('',(0.,0.)); +#7899 = VECTOR('',#7900,1.); +#7900 = DIRECTION('',(-1.,2.343516320473E-42)); +#7901 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7902 = ORIENTED_EDGE('',*,*,#7903,.T.); +#7903 = EDGE_CURVE('',#7874,#7904,#7906,.T.); +#7904 = VERTEX_POINT('',#7905); +#7905 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 13.949999999952)); +#7906 = SURFACE_CURVE('',#7907,(#7911,#7918),.PCURVE_S1.); +#7907 = LINE('',#7908,#7909); +#7908 = CARTESIAN_POINT('',(4.149999999882,-64.60000000007,31.8)); +#7909 = VECTOR('',#7910,1.); +#7910 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7911 = PCURVE('',#3390,#7912); +#7912 = DEFINITIONAL_REPRESENTATION('',(#7913),#7917); +#7913 = LINE('',#7914,#7915); +#7914 = CARTESIAN_POINT('',(-26.84999999998,13.650000000013)); +#7915 = VECTOR('',#7916,1.); +#7916 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7917 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7918 = PCURVE('',#7919,#7924); +#7919 = PLANE('',#7920); +#7920 = AXIS2_PLACEMENT_3D('',#7921,#7922,#7923); +#7921 = CARTESIAN_POINT('',(4.149999999882,-64.60000000007,31.8)); +#7922 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#7923 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7924 = DEFINITIONAL_REPRESENTATION('',(#7925),#7929); +#7925 = LINE('',#7926,#7927); +#7926 = CARTESIAN_POINT('',(0.,0.)); +#7927 = VECTOR('',#7928,1.); +#7928 = DIRECTION('',(1.,1.854674126415E-29)); +#7929 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7930 = ORIENTED_EDGE('',*,*,#7931,.F.); +#7931 = EDGE_CURVE('',#7932,#7904,#7934,.T.); +#7932 = VERTEX_POINT('',#7933); +#7933 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7934 = SURFACE_CURVE('',#7935,(#7939,#7946),.PCURVE_S1.); +#7935 = LINE('',#7936,#7937); +#7936 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#7937 = VECTOR('',#7938,1.); +#7938 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#7939 = PCURVE('',#3390,#7940); +#7940 = DEFINITIONAL_REPRESENTATION('',(#7941),#7945); +#7941 = LINE('',#7942,#7943); +#7942 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#7943 = VECTOR('',#7944,1.); +#7944 = DIRECTION('',(1.793662034336E-43,1.)); +#7945 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7946 = PCURVE('',#3870,#7947); +#7947 = DEFINITIONAL_REPRESENTATION('',(#7948),#7952); +#7948 = LINE('',#7949,#7950); +#7949 = CARTESIAN_POINT('',(0.,0.)); +#7950 = VECTOR('',#7951,1.); +#7951 = DIRECTION('',(-1.,0.)); +#7952 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7953 = ORIENTED_EDGE('',*,*,#7954,.F.); +#7954 = EDGE_CURVE('',#7955,#7932,#7957,.T.); +#7955 = VERTEX_POINT('',#7956); +#7956 = CARTESIAN_POINT('',(21.449999999882,-64.6000000001,11.5)); +#7957 = SURFACE_CURVE('',#7958,(#7962,#7969),.PCURVE_S1.); +#7958 = LINE('',#7959,#7960); +#7959 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7960 = VECTOR('',#7961,1.); +#7961 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#7962 = PCURVE('',#3390,#7963); +#7963 = DEFINITIONAL_REPRESENTATION('',(#7964),#7968); +#7964 = LINE('',#7965,#7966); +#7965 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#7966 = VECTOR('',#7967,1.); +#7967 = DIRECTION('',(-1.,0.)); +#7968 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7969 = PCURVE('',#7970,#7975); +#7970 = PLANE('',#7971); +#7971 = AXIS2_PLACEMENT_3D('',#7972,#7973,#7974); +#7972 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#7973 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#7974 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#7975 = DEFINITIONAL_REPRESENTATION('',(#7976),#7980); +#7976 = LINE('',#7977,#7978); +#7977 = CARTESIAN_POINT('',(0.,0.)); +#7978 = VECTOR('',#7979,1.); +#7979 = DIRECTION('',(-1.,-2.343516320473E-42)); +#7980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7981 = ORIENTED_EDGE('',*,*,#7982,.F.); +#7982 = EDGE_CURVE('',#7876,#7955,#7983,.T.); +#7983 = SURFACE_CURVE('',#7984,(#7988,#7995),.PCURVE_S1.); +#7984 = LINE('',#7985,#7986); +#7985 = CARTESIAN_POINT('',(1.149999999882,-64.60000000007,31.8)); +#7986 = VECTOR('',#7987,1.); +#7987 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#7988 = PCURVE('',#3390,#7989); +#7989 = DEFINITIONAL_REPRESENTATION('',(#7990),#7994); +#7990 = LINE('',#7991,#7992); +#7991 = CARTESIAN_POINT('',(-23.84999999998,13.650000000013)); +#7992 = VECTOR('',#7993,1.); +#7993 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#7994 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#7995 = PCURVE('',#7996,#8001); +#7996 = PLANE('',#7997); +#7997 = AXIS2_PLACEMENT_3D('',#7998,#7999,#8000); +#7998 = CARTESIAN_POINT('',(26.449999999893,-64.6000000001, + 6.499999999988)); +#7999 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#8000 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#8001 = DEFINITIONAL_REPRESENTATION('',(#8002),#8006); +#8002 = LINE('',#8003,#8004); +#8003 = CARTESIAN_POINT('',(35.779603128055,-2.292788492775E-15)); +#8004 = VECTOR('',#8005,1.); +#8005 = DIRECTION('',(-1.,8.10752882526E-29)); +#8006 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8007 = FACE_BOUND('',#8008,.T.); +#8008 = EDGE_LOOP('',(#8009,#8039,#8067,#8095)); +#8009 = ORIENTED_EDGE('',*,*,#8010,.T.); +#8010 = EDGE_CURVE('',#8011,#8013,#8015,.T.); +#8011 = VERTEX_POINT('',#8012); +#8012 = CARTESIAN_POINT('',(-13.55000000011,-64.60000000005,31.5)); +#8013 = VERTEX_POINT('',#8014); +#8014 = CARTESIAN_POINT('',(6.449999999882,-64.60000000008,11.5)); +#8015 = SURFACE_CURVE('',#8016,(#8020,#8027),.PCURVE_S1.); +#8016 = LINE('',#8017,#8018); +#8017 = CARTESIAN_POINT('',(-13.85000000011,-64.60000000005,31.8)); +#8018 = VECTOR('',#8019,1.); +#8019 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8020 = PCURVE('',#3390,#8021); +#8021 = DEFINITIONAL_REPRESENTATION('',(#8022),#8026); +#8022 = LINE('',#8023,#8024); +#8023 = CARTESIAN_POINT('',(-8.849999999989,13.650000000013)); +#8024 = VECTOR('',#8025,1.); +#8025 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8026 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8027 = PCURVE('',#8028,#8033); +#8028 = PLANE('',#8029); +#8029 = AXIS2_PLACEMENT_3D('',#8030,#8031,#8032); +#8030 = CARTESIAN_POINT('',(-13.85000000011,-64.60000000005,31.8)); +#8031 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#8032 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8033 = DEFINITIONAL_REPRESENTATION('',(#8034),#8038); +#8034 = LINE('',#8035,#8036); +#8035 = CARTESIAN_POINT('',(0.,0.)); +#8036 = VECTOR('',#8037,1.); +#8037 = DIRECTION('',(1.,1.854674126415E-29)); +#8038 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8039 = ORIENTED_EDGE('',*,*,#8040,.F.); +#8040 = EDGE_CURVE('',#8041,#8013,#8043,.T.); +#8041 = VERTEX_POINT('',#8042); +#8042 = CARTESIAN_POINT('',(3.449999999882,-64.60000000007,11.5)); +#8043 = SURFACE_CURVE('',#8044,(#8048,#8055),.PCURVE_S1.); +#8044 = LINE('',#8045,#8046); +#8045 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8046 = VECTOR('',#8047,1.); +#8047 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8048 = PCURVE('',#3390,#8049); +#8049 = DEFINITIONAL_REPRESENTATION('',(#8050),#8054); +#8050 = LINE('',#8051,#8052); +#8051 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#8052 = VECTOR('',#8053,1.); +#8053 = DIRECTION('',(-1.,0.)); +#8054 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8055 = PCURVE('',#8056,#8061); +#8056 = PLANE('',#8057); +#8057 = AXIS2_PLACEMENT_3D('',#8058,#8059,#8060); +#8058 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8059 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#8060 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8061 = DEFINITIONAL_REPRESENTATION('',(#8062),#8066); +#8062 = LINE('',#8063,#8064); +#8063 = CARTESIAN_POINT('',(0.,0.)); +#8064 = VECTOR('',#8065,1.); +#8065 = DIRECTION('',(-1.,-2.343516320473E-42)); +#8066 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8067 = ORIENTED_EDGE('',*,*,#8068,.F.); +#8068 = EDGE_CURVE('',#8069,#8041,#8071,.T.); +#8069 = VERTEX_POINT('',#8070); +#8070 = CARTESIAN_POINT('',(-16.55000000011,-64.60000000004,31.5)); +#8071 = SURFACE_CURVE('',#8072,(#8076,#8083),.PCURVE_S1.); +#8072 = LINE('',#8073,#8074); +#8073 = CARTESIAN_POINT('',(-16.85000000011,-64.60000000004,31.8)); +#8074 = VECTOR('',#8075,1.); +#8075 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8076 = PCURVE('',#3390,#8077); +#8077 = DEFINITIONAL_REPRESENTATION('',(#8078),#8082); +#8078 = LINE('',#8079,#8080); +#8079 = CARTESIAN_POINT('',(-5.849999999989,13.650000000013)); +#8080 = VECTOR('',#8081,1.); +#8081 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8082 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8083 = PCURVE('',#8084,#8089); +#8084 = PLANE('',#8085); +#8085 = AXIS2_PLACEMENT_3D('',#8086,#8087,#8088); +#8086 = CARTESIAN_POINT('',(8.449999999893,-64.60000000008, + 6.499999999988)); +#8087 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#8088 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#8089 = DEFINITIONAL_REPRESENTATION('',(#8090),#8094); +#8090 = LINE('',#8091,#8092); +#8091 = CARTESIAN_POINT('',(35.779603128055,1.191806622244E-14)); +#8092 = VECTOR('',#8093,1.); +#8093 = DIRECTION('',(-1.,8.10752882526E-29)); +#8094 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8095 = ORIENTED_EDGE('',*,*,#8096,.F.); +#8096 = EDGE_CURVE('',#8011,#8069,#8097,.T.); +#8097 = SURFACE_CURVE('',#8098,(#8102,#8109),.PCURVE_S1.); +#8098 = LINE('',#8099,#8100); +#8099 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8100 = VECTOR('',#8101,1.); +#8101 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8102 = PCURVE('',#3390,#8103); +#8103 = DEFINITIONAL_REPRESENTATION('',(#8104),#8108); +#8104 = LINE('',#8105,#8106); +#8105 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8106 = VECTOR('',#8107,1.); +#8107 = DIRECTION('',(1.,0.)); +#8108 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8109 = PCURVE('',#8110,#8115); +#8110 = PLANE('',#8111); +#8111 = AXIS2_PLACEMENT_3D('',#8112,#8113,#8114); +#8112 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8113 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#8114 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8115 = DEFINITIONAL_REPRESENTATION('',(#8116),#8120); +#8116 = LINE('',#8117,#8118); +#8117 = CARTESIAN_POINT('',(0.,0.)); +#8118 = VECTOR('',#8119,1.); +#8119 = DIRECTION('',(-1.,2.343516320473E-42)); +#8120 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8121 = FACE_BOUND('',#8122,.T.); +#8122 = EDGE_LOOP('',(#8123,#8153,#8181,#8209)); +#8123 = ORIENTED_EDGE('',*,*,#8124,.F.); +#8124 = EDGE_CURVE('',#8125,#8127,#8129,.T.); +#8125 = VERTEX_POINT('',#8126); +#8126 = CARTESIAN_POINT('',(-1.550000000118,-64.60000000006,31.5)); +#8127 = VERTEX_POINT('',#8128); +#8128 = CARTESIAN_POINT('',(-4.550000000118,-64.60000000006,31.5)); +#8129 = SURFACE_CURVE('',#8130,(#8134,#8141),.PCURVE_S1.); +#8130 = LINE('',#8131,#8132); +#8131 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8132 = VECTOR('',#8133,1.); +#8133 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8134 = PCURVE('',#3390,#8135); +#8135 = DEFINITIONAL_REPRESENTATION('',(#8136),#8140); +#8136 = LINE('',#8137,#8138); +#8137 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8138 = VECTOR('',#8139,1.); +#8139 = DIRECTION('',(1.,0.)); +#8140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8141 = PCURVE('',#8142,#8147); +#8142 = PLANE('',#8143); +#8143 = AXIS2_PLACEMENT_3D('',#8144,#8145,#8146); +#8144 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8145 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#8146 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8147 = DEFINITIONAL_REPRESENTATION('',(#8148),#8152); +#8148 = LINE('',#8149,#8150); +#8149 = CARTESIAN_POINT('',(0.,0.)); +#8150 = VECTOR('',#8151,1.); +#8151 = DIRECTION('',(-1.,2.343516320473E-42)); +#8152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8153 = ORIENTED_EDGE('',*,*,#8154,.T.); +#8154 = EDGE_CURVE('',#8125,#8155,#8157,.T.); +#8155 = VERTEX_POINT('',#8156); +#8156 = CARTESIAN_POINT('',(18.449999999882,-64.60000000009,11.5)); +#8157 = SURFACE_CURVE('',#8158,(#8162,#8169),.PCURVE_S1.); +#8158 = LINE('',#8159,#8160); +#8159 = CARTESIAN_POINT('',(-1.850000000118,-64.60000000006,31.8)); +#8160 = VECTOR('',#8161,1.); +#8161 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8162 = PCURVE('',#3390,#8163); +#8163 = DEFINITIONAL_REPRESENTATION('',(#8164),#8168); +#8164 = LINE('',#8165,#8166); +#8165 = CARTESIAN_POINT('',(-20.84999999998,13.650000000013)); +#8166 = VECTOR('',#8167,1.); +#8167 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8168 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8169 = PCURVE('',#8170,#8175); +#8170 = PLANE('',#8171); +#8171 = AXIS2_PLACEMENT_3D('',#8172,#8173,#8174); +#8172 = CARTESIAN_POINT('',(-1.850000000118,-64.60000000006,31.8)); +#8173 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#8174 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8175 = DEFINITIONAL_REPRESENTATION('',(#8176),#8180); +#8176 = LINE('',#8177,#8178); +#8177 = CARTESIAN_POINT('',(0.,0.)); +#8178 = VECTOR('',#8179,1.); +#8179 = DIRECTION('',(1.,1.854674126415E-29)); +#8180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8181 = ORIENTED_EDGE('',*,*,#8182,.F.); +#8182 = EDGE_CURVE('',#8183,#8155,#8185,.T.); +#8183 = VERTEX_POINT('',#8184); +#8184 = CARTESIAN_POINT('',(15.449999999882,-64.60000000009,11.5)); +#8185 = SURFACE_CURVE('',#8186,(#8190,#8197),.PCURVE_S1.); +#8186 = LINE('',#8187,#8188); +#8187 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8188 = VECTOR('',#8189,1.); +#8189 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8190 = PCURVE('',#3390,#8191); +#8191 = DEFINITIONAL_REPRESENTATION('',(#8192),#8196); +#8192 = LINE('',#8193,#8194); +#8193 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#8194 = VECTOR('',#8195,1.); +#8195 = DIRECTION('',(-1.,0.)); +#8196 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8197 = PCURVE('',#8198,#8203); +#8198 = PLANE('',#8199); +#8199 = AXIS2_PLACEMENT_3D('',#8200,#8201,#8202); +#8200 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8201 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#8202 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8203 = DEFINITIONAL_REPRESENTATION('',(#8204),#8208); +#8204 = LINE('',#8205,#8206); +#8205 = CARTESIAN_POINT('',(0.,0.)); +#8206 = VECTOR('',#8207,1.); +#8207 = DIRECTION('',(-1.,-2.343516320473E-42)); +#8208 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8209 = ORIENTED_EDGE('',*,*,#8210,.F.); +#8210 = EDGE_CURVE('',#8127,#8183,#8211,.T.); +#8211 = SURFACE_CURVE('',#8212,(#8216,#8223),.PCURVE_S1.); +#8212 = LINE('',#8213,#8214); +#8213 = CARTESIAN_POINT('',(-4.850000000118,-64.60000000006,31.8)); +#8214 = VECTOR('',#8215,1.); +#8215 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8216 = PCURVE('',#3390,#8217); +#8217 = DEFINITIONAL_REPRESENTATION('',(#8218),#8222); +#8218 = LINE('',#8219,#8220); +#8219 = CARTESIAN_POINT('',(-17.84999999998,13.650000000013)); +#8220 = VECTOR('',#8221,1.); +#8221 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8223 = PCURVE('',#8224,#8229); +#8224 = PLANE('',#8225); +#8225 = AXIS2_PLACEMENT_3D('',#8226,#8227,#8228); +#8226 = CARTESIAN_POINT('',(20.449999999893,-64.6000000001, + 6.499999999988)); +#8227 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#8228 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#8229 = DEFINITIONAL_REPRESENTATION('',(#8230),#8234); +#8230 = LINE('',#8231,#8232); +#8231 = CARTESIAN_POINT('',(35.779603128055,-2.292788492765E-15)); +#8232 = VECTOR('',#8233,1.); +#8233 = DIRECTION('',(-1.,8.10752882526E-29)); +#8234 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8235 = FACE_BOUND('',#8236,.T.); +#8236 = EDGE_LOOP('',(#8237,#8267,#8295,#8323)); +#8237 = ORIENTED_EDGE('',*,*,#8238,.T.); +#8238 = EDGE_CURVE('',#8239,#8241,#8243,.T.); +#8239 = VERTEX_POINT('',#8240); +#8240 = CARTESIAN_POINT('',(-7.550000000118,-64.60000000006,31.5)); +#8241 = VERTEX_POINT('',#8242); +#8242 = CARTESIAN_POINT('',(12.449999999882,-64.60000000008,11.5)); +#8243 = SURFACE_CURVE('',#8244,(#8248,#8255),.PCURVE_S1.); +#8244 = LINE('',#8245,#8246); +#8245 = CARTESIAN_POINT('',(-7.850000000118,-64.60000000006,31.8)); +#8246 = VECTOR('',#8247,1.); +#8247 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8248 = PCURVE('',#3390,#8249); +#8249 = DEFINITIONAL_REPRESENTATION('',(#8250),#8254); +#8250 = LINE('',#8251,#8252); +#8251 = CARTESIAN_POINT('',(-14.84999999998,13.650000000013)); +#8252 = VECTOR('',#8253,1.); +#8253 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8254 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8255 = PCURVE('',#8256,#8261); +#8256 = PLANE('',#8257); +#8257 = AXIS2_PLACEMENT_3D('',#8258,#8259,#8260); +#8258 = CARTESIAN_POINT('',(-7.850000000118,-64.60000000006,31.8)); +#8259 = DIRECTION('',(0.707106781187,-1.016437958864E-12,0.707106781187) + ); +#8260 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8261 = DEFINITIONAL_REPRESENTATION('',(#8262),#8266); +#8262 = LINE('',#8263,#8264); +#8263 = CARTESIAN_POINT('',(0.,0.)); +#8264 = VECTOR('',#8265,1.); +#8265 = DIRECTION('',(1.,1.854674126415E-29)); +#8266 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8267 = ORIENTED_EDGE('',*,*,#8268,.F.); +#8268 = EDGE_CURVE('',#8269,#8241,#8271,.T.); +#8269 = VERTEX_POINT('',#8270); +#8270 = CARTESIAN_POINT('',(9.449999999882,-64.60000000008,11.5)); +#8271 = SURFACE_CURVE('',#8272,(#8276,#8283),.PCURVE_S1.); +#8272 = LINE('',#8273,#8274); +#8273 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8274 = VECTOR('',#8275,1.); +#8275 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8276 = PCURVE('',#3390,#8277); +#8277 = DEFINITIONAL_REPRESENTATION('',(#8278),#8282); +#8278 = LINE('',#8279,#8280); +#8279 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#8280 = VECTOR('',#8281,1.); +#8281 = DIRECTION('',(-1.,0.)); +#8282 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8283 = PCURVE('',#8284,#8289); +#8284 = PLANE('',#8285); +#8285 = AXIS2_PLACEMENT_3D('',#8286,#8287,#8288); +#8286 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#8287 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#8288 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8289 = DEFINITIONAL_REPRESENTATION('',(#8290),#8294); +#8290 = LINE('',#8291,#8292); +#8291 = CARTESIAN_POINT('',(0.,0.)); +#8292 = VECTOR('',#8293,1.); +#8293 = DIRECTION('',(-1.,-2.343516320473E-42)); +#8294 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8295 = ORIENTED_EDGE('',*,*,#8296,.F.); +#8296 = EDGE_CURVE('',#8297,#8269,#8299,.T.); +#8297 = VERTEX_POINT('',#8298); +#8298 = CARTESIAN_POINT('',(-10.55000000011,-64.60000000005,31.5)); +#8299 = SURFACE_CURVE('',#8300,(#8304,#8311),.PCURVE_S1.); +#8300 = LINE('',#8301,#8302); +#8301 = CARTESIAN_POINT('',(-10.85000000011,-64.60000000005,31.8)); +#8302 = VECTOR('',#8303,1.); +#8303 = DIRECTION('',(0.707106781187,-1.017632935685E-12,-0.707106781187 + )); +#8304 = PCURVE('',#3390,#8305); +#8305 = DEFINITIONAL_REPRESENTATION('',(#8306),#8310); +#8306 = LINE('',#8307,#8308); +#8307 = CARTESIAN_POINT('',(-11.84999999998,13.650000000013)); +#8308 = VECTOR('',#8309,1.); +#8309 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8311 = PCURVE('',#8312,#8317); +#8312 = PLANE('',#8313); +#8313 = AXIS2_PLACEMENT_3D('',#8314,#8315,#8316); +#8314 = CARTESIAN_POINT('',(14.449999999893,-64.60000000009, + 6.499999999988)); +#8315 = DIRECTION('',(-0.707106781187,1.016437958864E-12,-0.707106781187 + )); +#8316 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187) + ); +#8317 = DEFINITIONAL_REPRESENTATION('',(#8318),#8322); +#8318 = LINE('',#8319,#8320); +#8319 = CARTESIAN_POINT('',(35.779603128055,9.718319451365E-14)); +#8320 = VECTOR('',#8321,1.); +#8321 = DIRECTION('',(-1.,8.10752882526E-29)); +#8322 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8323 = ORIENTED_EDGE('',*,*,#8324,.F.); +#8324 = EDGE_CURVE('',#8239,#8297,#8325,.T.); +#8325 = SURFACE_CURVE('',#8326,(#8330,#8337),.PCURVE_S1.); +#8326 = LINE('',#8327,#8328); +#8327 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8328 = VECTOR('',#8329,1.); +#8329 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#8330 = PCURVE('',#3390,#8331); +#8331 = DEFINITIONAL_REPRESENTATION('',(#8332),#8336); +#8332 = LINE('',#8333,#8334); +#8333 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8334 = VECTOR('',#8335,1.); +#8335 = DIRECTION('',(1.,0.)); +#8336 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8337 = PCURVE('',#8338,#8343); +#8338 = PLANE('',#8339); +#8339 = AXIS2_PLACEMENT_3D('',#8340,#8341,#8342); +#8340 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#8341 = DIRECTION('',(1.293459215968E-27,1.833155447161E-15,1.)); +#8342 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#8343 = DEFINITIONAL_REPRESENTATION('',(#8344),#8348); +#8344 = LINE('',#8345,#8346); +#8345 = CARTESIAN_POINT('',(0.,0.)); +#8346 = VECTOR('',#8347,1.); +#8347 = DIRECTION('',(-1.,2.343516320473E-42)); +#8348 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8349 = ADVANCED_FACE('',(#8350),#3362,.T.); +#8350 = FACE_BOUND('',#8351,.T.); +#8351 = EDGE_LOOP('',(#8352,#8353,#8374,#8375)); +#8352 = ORIENTED_EDGE('',*,*,#3345,.T.); +#8353 = ORIENTED_EDGE('',*,*,#8354,.T.); +#8354 = EDGE_CURVE('',#3318,#6130,#8355,.T.); +#8355 = SURFACE_CURVE('',#8356,(#8360,#8367),.PCURVE_S1.); +#8356 = LINE('',#8357,#8358); +#8357 = CARTESIAN_POINT('',(28.999999999935,-61.60000000011, + 11.324999999994)); +#8358 = VECTOR('',#8359,1.); +#8359 = DIRECTION('',(-1.221646432603E-27,8.54607999747E-17,1.)); +#8360 = PCURVE('',#3362,#8361); +#8361 = DEFINITIONAL_REPRESENTATION('',(#8362),#8366); +#8362 = LINE('',#8363,#8364); +#8363 = CARTESIAN_POINT('',(5.497787143782,0.)); +#8364 = VECTOR('',#8365,1.); +#8365 = DIRECTION('',(0.,-1.)); +#8366 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8367 = PCURVE('',#3333,#8368); +#8368 = DEFINITIONAL_REPRESENTATION('',(#8369),#8373); +#8369 = LINE('',#8370,#8371); +#8370 = CARTESIAN_POINT('',(6.824999999993,3.)); +#8371 = VECTOR('',#8372,1.); +#8372 = DIRECTION('',(1.,-2.612289469706E-16)); +#8373 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8374 = ORIENTED_EDGE('',*,*,#6129,.T.); +#8375 = ORIENTED_EDGE('',*,*,#6980,.T.); +#8376 = ADVANCED_FACE('',(#8377,#8403,#8434),#3333,.F.); +#8377 = FACE_BOUND('',#8378,.T.); +#8378 = EDGE_LOOP('',(#8379,#8380,#8381,#8402)); +#8379 = ORIENTED_EDGE('',*,*,#8354,.F.); +#8380 = ORIENTED_EDGE('',*,*,#3317,.T.); +#8381 = ORIENTED_EDGE('',*,*,#8382,.F.); +#8382 = EDGE_CURVE('',#6154,#3289,#8383,.T.); +#8383 = SURFACE_CURVE('',#8384,(#8388,#8395),.PCURVE_S1.); +#8384 = LINE('',#8385,#8386); +#8385 = CARTESIAN_POINT('',(29.000000000112,61.599999999992, + 11.324999999993)); +#8386 = VECTOR('',#8387,1.); +#8387 = DIRECTION('',(-1.347058560847E-27,-1.870159327101E-15,-1.)); +#8388 = PCURVE('',#3333,#8389); +#8389 = DEFINITIONAL_REPRESENTATION('',(#8390),#8394); +#8390 = LINE('',#8391,#8392); +#8391 = CARTESIAN_POINT('',(6.824999999993,126.2000000001)); +#8392 = VECTOR('',#8393,1.); +#8393 = DIRECTION('',(-1.,-1.523469580156E-15)); +#8394 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8395 = PCURVE('',#3305,#8396); +#8396 = DEFINITIONAL_REPRESENTATION('',(#8397),#8401); +#8397 = LINE('',#8398,#8399); +#8398 = CARTESIAN_POINT('',(7.068583470578,7.105427357601E-15)); +#8399 = VECTOR('',#8400,1.); +#8400 = DIRECTION('',(2.514328614587E-16,1.)); +#8401 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8402 = ORIENTED_EDGE('',*,*,#6153,.F.); +#8403 = FACE_BOUND('',#8404,.T.); +#8404 = EDGE_LOOP('',(#8405)); +#8405 = ORIENTED_EDGE('',*,*,#8406,.T.); +#8406 = EDGE_CURVE('',#8407,#8407,#8409,.T.); +#8407 = VERTEX_POINT('',#8408); +#8408 = CARTESIAN_POINT('',(29.000000000023,31.949999999942, + 24.499999999965)); +#8409 = SURFACE_CURVE('',#8410,(#8415,#8422),.PCURVE_S1.); +#8410 = CIRCLE('',#8411,1.05); +#8411 = AXIS2_PLACEMENT_3D('',#8412,#8413,#8414); +#8412 = CARTESIAN_POINT('',(28.99999999993,32.999999999942, + 24.499999999965)); +#8413 = DIRECTION('',(-1.,1.439293502184E-12,-1.344649606698E-27)); +#8414 = DIRECTION('',(1.439293502184E-12,1.,-1.224646799147E-16)); +#8415 = PCURVE('',#3333,#8416); +#8416 = DEFINITIONAL_REPRESENTATION('',(#8417),#8421); +#8417 = CIRCLE('',#8418,1.05); +#8418 = AXIS2_PLACEMENT_2D('',#8419,#8420); +#8419 = CARTESIAN_POINT('',(19.999999999965,97.600000000055)); +#8420 = DIRECTION('',(2.242250670306E-16,1.)); +#8421 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8422 = PCURVE('',#8423,#8428); +#8423 = CYLINDRICAL_SURFACE('',#8424,1.05); +#8424 = AXIS2_PLACEMENT_3D('',#8425,#8426,#8427); +#8425 = CARTESIAN_POINT('',(29.000000000023,32.999999999942, + 24.499999999965)); +#8426 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#8427 = DIRECTION('',(4.45098715844E-61,1.,-1.224646799147E-16)); +#8428 = DEFINITIONAL_REPRESENTATION('',(#8429),#8433); +#8429 = LINE('',#8430,#8431); +#8430 = CARTESIAN_POINT('',(0.,9.451639471081E-11)); +#8431 = VECTOR('',#8432,1.); +#8432 = DIRECTION('',(1.,0.)); +#8433 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8434 = FACE_BOUND('',#8435,.T.); +#8435 = EDGE_LOOP('',(#8436)); +#8436 = ORIENTED_EDGE('',*,*,#8437,.T.); +#8437 = EDGE_CURVE('',#8438,#8438,#8440,.T.); +#8438 = VERTEX_POINT('',#8439); +#8439 = CARTESIAN_POINT('',(29.000000000023,-34.05000000005, + 24.499999999965)); +#8440 = SURFACE_CURVE('',#8441,(#8446,#8453),.PCURVE_S1.); +#8441 = CIRCLE('',#8442,1.05); +#8442 = AXIS2_PLACEMENT_3D('',#8443,#8444,#8445); +#8443 = CARTESIAN_POINT('',(28.99999999993,-33.00000000005, + 24.499999999965)); +#8444 = DIRECTION('',(-1.,1.439293502184E-12,-1.344649606698E-27)); +#8445 = DIRECTION('',(1.439293502184E-12,1.,-1.224646799147E-16)); +#8446 = PCURVE('',#3333,#8447); +#8447 = DEFINITIONAL_REPRESENTATION('',(#8448),#8452); +#8448 = CIRCLE('',#8449,1.05); +#8449 = AXIS2_PLACEMENT_2D('',#8450,#8451); +#8450 = CARTESIAN_POINT('',(19.999999999965,31.600000000055)); +#8451 = DIRECTION('',(2.242250670306E-16,1.)); +#8452 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8453 = PCURVE('',#8454,#8459); +#8454 = CYLINDRICAL_SURFACE('',#8455,1.05); +#8455 = AXIS2_PLACEMENT_3D('',#8456,#8457,#8458); +#8456 = CARTESIAN_POINT('',(29.000000000023,-33.00000000005, + 24.499999999965)); +#8457 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#8458 = DIRECTION('',(4.45098715844E-61,1.,-1.224646799147E-16)); +#8459 = DEFINITIONAL_REPRESENTATION('',(#8460),#8464); +#8460 = LINE('',#8461,#8462); +#8461 = CARTESIAN_POINT('',(0.,9.451639471081E-11)); +#8462 = VECTOR('',#8463,1.); +#8463 = DIRECTION('',(1.,0.)); +#8464 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8465 = ADVANCED_FACE('',(#8466),#3305,.T.); +#8466 = FACE_BOUND('',#8467,.T.); +#8467 = EDGE_LOOP('',(#8468,#8469,#8490,#8491)); +#8468 = ORIENTED_EDGE('',*,*,#3288,.T.); +#8469 = ORIENTED_EDGE('',*,*,#8470,.T.); +#8470 = EDGE_CURVE('',#3261,#6177,#8471,.T.); +#8471 = SURFACE_CURVE('',#8472,(#8476,#8483),.PCURVE_S1.); +#8472 = LINE('',#8473,#8474); +#8473 = CARTESIAN_POINT('',(26.000000000112,64.599999999996, + 11.324999999993)); +#8474 = VECTOR('',#8475,1.); +#8475 = DIRECTION('',(1.347058560847E-27,1.870159327101E-15,1.)); +#8476 = PCURVE('',#3305,#8477); +#8477 = DEFINITIONAL_REPRESENTATION('',(#8478),#8482); +#8478 = LINE('',#8479,#8480); +#8479 = CARTESIAN_POINT('',(5.497787143781,0.)); +#8480 = VECTOR('',#8481,1.); +#8481 = DIRECTION('',(1.04491578788E-16,-1.)); +#8482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8483 = PCURVE('',#3276,#8484); +#8484 = DEFINITIONAL_REPRESENTATION('',(#8485),#8489); +#8485 = LINE('',#8486,#8487); +#8486 = CARTESIAN_POINT('',(-48.70000000012,-6.824999999993)); +#8487 = VECTOR('',#8488,1.); +#8488 = DIRECTION('',(-1.28825558991E-27,1.)); +#8489 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8490 = ORIENTED_EDGE('',*,*,#6176,.T.); +#8491 = ORIENTED_EDGE('',*,*,#8382,.T.); +#8492 = ADVANCED_FACE('',(#8493),#3191,.T.); +#8493 = FACE_BOUND('',#8494,.T.); +#8494 = EDGE_LOOP('',(#8495,#8496,#8517,#8518)); +#8495 = ORIENTED_EDGE('',*,*,#6270,.T.); +#8496 = ORIENTED_EDGE('',*,*,#8497,.T.); +#8497 = EDGE_CURVE('',#6248,#3175,#8498,.T.); +#8498 = SURFACE_CURVE('',#8499,(#8503,#8510),.PCURVE_S1.); +#8499 = LINE('',#8500,#8501); +#8500 = CARTESIAN_POINT('',(-33.,41.599999999996,21.5)); +#8501 = VECTOR('',#8502,1.); +#8502 = DIRECTION('',(-6.650456067787E-29,-1.224646799147E-16,-1.)); +#8503 = PCURVE('',#3191,#8504); +#8504 = DEFINITIONAL_REPRESENTATION('',(#8505),#8509); +#8505 = LINE('',#8506,#8507); +#8506 = CARTESIAN_POINT('',(5.497787143782,0.)); +#8507 = VECTOR('',#8508,1.); +#8508 = DIRECTION('',(0.,-1.)); +#8509 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8510 = PCURVE('',#3219,#8511); +#8511 = DEFINITIONAL_REPRESENTATION('',(#8512),#8516); +#8512 = LINE('',#8513,#8514); +#8513 = CARTESIAN_POINT('',(17.,23.)); +#8514 = VECTOR('',#8515,1.); +#8515 = DIRECTION('',(1.,-1.486465700216E-15)); +#8516 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8517 = ORIENTED_EDGE('',*,*,#3174,.T.); +#8518 = ORIENTED_EDGE('',*,*,#8519,.T.); +#8519 = EDGE_CURVE('',#3147,#6271,#8520,.T.); +#8520 = SURFACE_CURVE('',#8521,(#8525,#8532),.PCURVE_S1.); +#8521 = LINE('',#8522,#8523); +#8522 = CARTESIAN_POINT('',(-30.,38.599999999996,21.5)); +#8523 = VECTOR('',#8524,1.); +#8524 = DIRECTION('',(6.650456067787E-29,1.224646799147E-16,1.)); +#8525 = PCURVE('',#3191,#8526); +#8526 = DEFINITIONAL_REPRESENTATION('',(#8527),#8531); +#8527 = LINE('',#8528,#8529); +#8528 = CARTESIAN_POINT('',(7.068583470577,0.)); +#8529 = VECTOR('',#8530,1.); +#8530 = DIRECTION('',(0.,1.)); +#8531 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8532 = PCURVE('',#3162,#8533); +#8533 = DEFINITIONAL_REPRESENTATION('',(#8534),#8538); +#8534 = LINE('',#8535,#8536); +#8535 = CARTESIAN_POINT('',(3.,17.)); +#8536 = VECTOR('',#8537,1.); +#8537 = DIRECTION('',(3.399009264875E-31,1.)); +#8538 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8539 = ADVANCED_FACE('',(#8540),#3219,.T.); +#8540 = FACE_BOUND('',#8541,.T.); +#8541 = EDGE_LOOP('',(#8542,#8543,#8544,#8565)); +#8542 = ORIENTED_EDGE('',*,*,#8497,.F.); +#8543 = ORIENTED_EDGE('',*,*,#6247,.F.); +#8544 = ORIENTED_EDGE('',*,*,#8545,.F.); +#8545 = EDGE_CURVE('',#3204,#6224,#8546,.T.); +#8546 = SURFACE_CURVE('',#8547,(#8551,#8558),.PCURVE_S1.); +#8547 = LINE('',#8548,#8549); +#8548 = CARTESIAN_POINT('',(-33.,61.599999999996,28.324999999993)); +#8549 = VECTOR('',#8550,1.); +#8550 = DIRECTION('',(5.874323732859E-29,1.870159327101E-15,1.)); +#8551 = PCURVE('',#3219,#8552); +#8552 = DEFINITIONAL_REPRESENTATION('',(#8553),#8557); +#8553 = LINE('',#8554,#8555); +#8554 = CARTESIAN_POINT('',(10.175000000007,3.)); +#8555 = VECTOR('',#8556,1.); +#8556 = DIRECTION('',(-1.,-2.612289469706E-16)); +#8557 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8558 = PCURVE('',#3248,#8559); +#8559 = DEFINITIONAL_REPRESENTATION('',(#8560),#8564); +#8560 = LINE('',#8561,#8562); +#8561 = CARTESIAN_POINT('',(-0.785398163397,-7.105427357601E-15)); +#8562 = VECTOR('',#8563,1.); +#8563 = DIRECTION('',(0.,-1.)); +#8564 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8565 = ORIENTED_EDGE('',*,*,#3203,.T.); +#8566 = ADVANCED_FACE('',(#8567),#3248,.T.); +#8567 = FACE_BOUND('',#8568,.T.); +#8568 = EDGE_LOOP('',(#8569,#8570,#8571,#8572)); +#8569 = ORIENTED_EDGE('',*,*,#3231,.T.); +#8570 = ORIENTED_EDGE('',*,*,#8545,.T.); +#8571 = ORIENTED_EDGE('',*,*,#6223,.T.); +#8572 = ORIENTED_EDGE('',*,*,#8573,.T.); +#8573 = EDGE_CURVE('',#6201,#3232,#8574,.T.); +#8574 = SURFACE_CURVE('',#8575,(#8579,#8586),.PCURVE_S1.); +#8575 = LINE('',#8576,#8577); +#8576 = CARTESIAN_POINT('',(-30.,64.599999999996,28.324999999993)); +#8577 = VECTOR('',#8578,1.); +#8578 = DIRECTION('',(-5.874323732859E-29,-1.870159327101E-15,-1.)); +#8579 = PCURVE('',#3248,#8580); +#8580 = DEFINITIONAL_REPRESENTATION('',(#8581),#8585); +#8581 = LINE('',#8582,#8583); +#8582 = CARTESIAN_POINT('',(0.785398163397,-7.105427357601E-15)); +#8583 = VECTOR('',#8584,1.); +#8584 = DIRECTION('',(5.224578939389E-17,1.)); +#8585 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8586 = PCURVE('',#3276,#8587); +#8587 = DEFINITIONAL_REPRESENTATION('',(#8588),#8592); +#8588 = LINE('',#8589,#8590); +#8589 = CARTESIAN_POINT('',(7.29999999999,10.175000000007)); +#8590 = VECTOR('',#8591,1.); +#8591 = DIRECTION('',(-5.973360911577E-32,-1.)); +#8592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8593 = ADVANCED_FACE('',(#8594,#8600,#8714,#8856,#8970,#9084,#9198, + #9284,#9398,#9540,#9654,#9768,#9882),#3276,.T.); +#8594 = FACE_BOUND('',#8595,.T.); +#8595 = EDGE_LOOP('',(#8596,#8597,#8598,#8599)); +#8596 = ORIENTED_EDGE('',*,*,#8470,.F.); +#8597 = ORIENTED_EDGE('',*,*,#3260,.T.); +#8598 = ORIENTED_EDGE('',*,*,#8573,.F.); +#8599 = ORIENTED_EDGE('',*,*,#6200,.T.); +#8600 = FACE_BOUND('',#8601,.T.); +#8601 = EDGE_LOOP('',(#8602,#8632,#8660,#8688)); +#8602 = ORIENTED_EDGE('',*,*,#8603,.T.); +#8603 = EDGE_CURVE('',#8604,#8606,#8608,.T.); +#8604 = VERTEX_POINT('',#8605); +#8605 = CARTESIAN_POINT('',(16.449999999975,64.599999999996,31.5)); +#8606 = VERTEX_POINT('',#8607); +#8607 = CARTESIAN_POINT('',(13.449999999975,64.599999999996,31.5)); +#8608 = SURFACE_CURVE('',#8609,(#8613,#8620),.PCURVE_S1.); +#8609 = LINE('',#8610,#8611); +#8610 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8611 = VECTOR('',#8612,1.); +#8612 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8613 = PCURVE('',#3276,#8614); +#8614 = DEFINITIONAL_REPRESENTATION('',(#8615),#8619); +#8615 = LINE('',#8616,#8617); +#8616 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8617 = VECTOR('',#8618,1.); +#8618 = DIRECTION('',(1.,0.)); +#8619 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8620 = PCURVE('',#8621,#8626); +#8621 = PLANE('',#8622); +#8622 = AXIS2_PLACEMENT_3D('',#8623,#8624,#8625); +#8623 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8624 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#8625 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8626 = DEFINITIONAL_REPRESENTATION('',(#8627),#8631); +#8627 = LINE('',#8628,#8629); +#8628 = CARTESIAN_POINT('',(0.,0.)); +#8629 = VECTOR('',#8630,1.); +#8630 = DIRECTION('',(-1.,1.62688410619E-44)); +#8631 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8632 = ORIENTED_EDGE('',*,*,#8633,.T.); +#8633 = EDGE_CURVE('',#8606,#8634,#8636,.T.); +#8634 = VERTEX_POINT('',#8635); +#8635 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 22.949999999951)); +#8636 = SURFACE_CURVE('',#8637,(#8641,#8648),.PCURVE_S1.); +#8637 = LINE('',#8638,#8639); +#8638 = CARTESIAN_POINT('',(13.149999999975,64.599999999996,31.8)); +#8639 = VECTOR('',#8640,1.); +#8640 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8641 = PCURVE('',#3276,#8642); +#8642 = DEFINITIONAL_REPRESENTATION('',(#8643),#8647); +#8643 = LINE('',#8644,#8645); +#8644 = CARTESIAN_POINT('',(-35.84999999998,13.650000000013)); +#8645 = VECTOR('',#8646,1.); +#8646 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8647 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8648 = PCURVE('',#8649,#8654); +#8649 = PLANE('',#8650); +#8650 = AXIS2_PLACEMENT_3D('',#8651,#8652,#8653); +#8651 = CARTESIAN_POINT('',(38.449999999986,64.599999999996, + 6.499999999988)); +#8652 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#8653 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#8654 = DEFINITIONAL_REPRESENTATION('',(#8655),#8659); +#8655 = LINE('',#8656,#8657); +#8656 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#8657 = VECTOR('',#8658,1.); +#8658 = DIRECTION('',(-1.,-3.871099052181E-31)); +#8659 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8660 = ORIENTED_EDGE('',*,*,#8661,.T.); +#8661 = EDGE_CURVE('',#8634,#8662,#8664,.T.); +#8662 = VERTEX_POINT('',#8663); +#8663 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 25.949999999952)); +#8664 = SURFACE_CURVE('',#8665,(#8669,#8676),.PCURVE_S1.); +#8665 = LINE('',#8666,#8667); +#8666 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#8667 = VECTOR('',#8668,1.); +#8668 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#8669 = PCURVE('',#3276,#8670); +#8670 = DEFINITIONAL_REPRESENTATION('',(#8671),#8675); +#8671 = LINE('',#8672,#8673); +#8672 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#8673 = VECTOR('',#8674,1.); +#8674 = DIRECTION('',(0.,1.)); +#8675 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8676 = PCURVE('',#8677,#8682); +#8677 = PLANE('',#8678); +#8678 = AXIS2_PLACEMENT_3D('',#8679,#8680,#8681); +#8679 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#8680 = DIRECTION('',(-1.,-4.440892098501E-15,6.710814671636E-29)); +#8681 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#8682 = DEFINITIONAL_REPRESENTATION('',(#8683),#8687); +#8683 = LINE('',#8684,#8685); +#8684 = CARTESIAN_POINT('',(0.,0.)); +#8685 = VECTOR('',#8686,1.); +#8686 = DIRECTION('',(-1.,-3.944304526105E-31)); +#8687 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8688 = ORIENTED_EDGE('',*,*,#8689,.F.); +#8689 = EDGE_CURVE('',#8604,#8662,#8690,.T.); +#8690 = SURFACE_CURVE('',#8691,(#8695,#8702),.PCURVE_S1.); +#8691 = LINE('',#8692,#8693); +#8692 = CARTESIAN_POINT('',(16.149999999975,64.599999999996,31.8)); +#8693 = VECTOR('',#8694,1.); +#8694 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8695 = PCURVE('',#3276,#8696); +#8696 = DEFINITIONAL_REPRESENTATION('',(#8697),#8701); +#8697 = LINE('',#8698,#8699); +#8698 = CARTESIAN_POINT('',(-38.84999999998,13.650000000013)); +#8699 = VECTOR('',#8700,1.); +#8700 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8701 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8702 = PCURVE('',#8703,#8708); +#8703 = PLANE('',#8704); +#8704 = AXIS2_PLACEMENT_3D('',#8705,#8706,#8707); +#8705 = CARTESIAN_POINT('',(16.149999999975,64.599999999996,31.8)); +#8706 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#8707 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8708 = DEFINITIONAL_REPRESENTATION('',(#8709),#8713); +#8709 = LINE('',#8710,#8711); +#8710 = CARTESIAN_POINT('',(0.,0.)); +#8711 = VECTOR('',#8712,1.); +#8712 = DIRECTION('',(1.,-4.361251546428E-31)); +#8713 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8714 = FACE_BOUND('',#8715,.T.); +#8715 = EDGE_LOOP('',(#8716,#8746,#8774,#8802,#8830)); +#8716 = ORIENTED_EDGE('',*,*,#8717,.T.); +#8717 = EDGE_CURVE('',#8718,#8720,#8722,.T.); +#8718 = VERTEX_POINT('',#8719); +#8719 = CARTESIAN_POINT('',(4.449999999975,64.599999999996,31.5)); +#8720 = VERTEX_POINT('',#8721); +#8721 = CARTESIAN_POINT('',(1.449999999975,64.599999999996,31.5)); +#8722 = SURFACE_CURVE('',#8723,(#8727,#8734),.PCURVE_S1.); +#8723 = LINE('',#8724,#8725); +#8724 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8725 = VECTOR('',#8726,1.); +#8726 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8727 = PCURVE('',#3276,#8728); +#8728 = DEFINITIONAL_REPRESENTATION('',(#8729),#8733); +#8729 = LINE('',#8730,#8731); +#8730 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8731 = VECTOR('',#8732,1.); +#8732 = DIRECTION('',(1.,0.)); +#8733 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8734 = PCURVE('',#8735,#8740); +#8735 = PLANE('',#8736); +#8736 = AXIS2_PLACEMENT_3D('',#8737,#8738,#8739); +#8737 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8738 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#8739 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8740 = DEFINITIONAL_REPRESENTATION('',(#8741),#8745); +#8741 = LINE('',#8742,#8743); +#8742 = CARTESIAN_POINT('',(0.,0.)); +#8743 = VECTOR('',#8744,1.); +#8744 = DIRECTION('',(-1.,1.62688410619E-44)); +#8745 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8746 = ORIENTED_EDGE('',*,*,#8747,.T.); +#8747 = EDGE_CURVE('',#8720,#8748,#8750,.T.); +#8748 = VERTEX_POINT('',#8749); +#8749 = CARTESIAN_POINT('',(21.449999999974,64.599999999996,11.5)); +#8750 = SURFACE_CURVE('',#8751,(#8755,#8762),.PCURVE_S1.); +#8751 = LINE('',#8752,#8753); +#8752 = CARTESIAN_POINT('',(1.149999999975,64.599999999996,31.8)); +#8753 = VECTOR('',#8754,1.); +#8754 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8755 = PCURVE('',#3276,#8756); +#8756 = DEFINITIONAL_REPRESENTATION('',(#8757),#8761); +#8757 = LINE('',#8758,#8759); +#8758 = CARTESIAN_POINT('',(-23.84999999998,13.650000000013)); +#8759 = VECTOR('',#8760,1.); +#8760 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8761 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8762 = PCURVE('',#8763,#8768); +#8763 = PLANE('',#8764); +#8764 = AXIS2_PLACEMENT_3D('',#8765,#8766,#8767); +#8765 = CARTESIAN_POINT('',(26.449999999986,64.599999999996, + 6.499999999988)); +#8766 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#8767 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#8768 = DEFINITIONAL_REPRESENTATION('',(#8769),#8773); +#8769 = LINE('',#8770,#8771); +#8770 = CARTESIAN_POINT('',(35.779603128055,-7.34651991656E-14)); +#8771 = VECTOR('',#8772,1.); +#8772 = DIRECTION('',(-1.,-3.871099052181E-31)); +#8773 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8774 = ORIENTED_EDGE('',*,*,#8775,.T.); +#8775 = EDGE_CURVE('',#8748,#8776,#8778,.T.); +#8776 = VERTEX_POINT('',#8777); +#8777 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#8778 = SURFACE_CURVE('',#8779,(#8783,#8790),.PCURVE_S1.); +#8779 = LINE('',#8780,#8781); +#8780 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#8781 = VECTOR('',#8782,1.); +#8782 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8783 = PCURVE('',#3276,#8784); +#8784 = DEFINITIONAL_REPRESENTATION('',(#8785),#8789); +#8785 = LINE('',#8786,#8787); +#8786 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#8787 = VECTOR('',#8788,1.); +#8788 = DIRECTION('',(-1.,0.)); +#8789 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8790 = PCURVE('',#8791,#8796); +#8791 = PLANE('',#8792); +#8792 = AXIS2_PLACEMENT_3D('',#8793,#8794,#8795); +#8793 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#8794 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#8795 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8796 = DEFINITIONAL_REPRESENTATION('',(#8797),#8801); +#8797 = LINE('',#8798,#8799); +#8798 = CARTESIAN_POINT('',(0.,0.)); +#8799 = VECTOR('',#8800,1.); +#8800 = DIRECTION('',(-1.,-1.62688410619E-44)); +#8801 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8802 = ORIENTED_EDGE('',*,*,#8803,.T.); +#8803 = EDGE_CURVE('',#8776,#8804,#8806,.T.); +#8804 = VERTEX_POINT('',#8805); +#8805 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 13.949999999952)); +#8806 = SURFACE_CURVE('',#8807,(#8811,#8818),.PCURVE_S1.); +#8807 = LINE('',#8808,#8809); +#8808 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#8809 = VECTOR('',#8810,1.); +#8810 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#8811 = PCURVE('',#3276,#8812); +#8812 = DEFINITIONAL_REPRESENTATION('',(#8813),#8817); +#8813 = LINE('',#8814,#8815); +#8814 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#8815 = VECTOR('',#8816,1.); +#8816 = DIRECTION('',(0.,1.)); +#8817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8818 = PCURVE('',#8819,#8824); +#8819 = PLANE('',#8820); +#8820 = AXIS2_PLACEMENT_3D('',#8821,#8822,#8823); +#8821 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#8822 = DIRECTION('',(-1.,-4.440892098501E-15,6.710814671636E-29)); +#8823 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#8824 = DEFINITIONAL_REPRESENTATION('',(#8825),#8829); +#8825 = LINE('',#8826,#8827); +#8826 = CARTESIAN_POINT('',(0.,0.)); +#8827 = VECTOR('',#8828,1.); +#8828 = DIRECTION('',(-1.,-3.944304526105E-31)); +#8829 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8830 = ORIENTED_EDGE('',*,*,#8831,.F.); +#8831 = EDGE_CURVE('',#8718,#8804,#8832,.T.); +#8832 = SURFACE_CURVE('',#8833,(#8837,#8844),.PCURVE_S1.); +#8833 = LINE('',#8834,#8835); +#8834 = CARTESIAN_POINT('',(4.149999999975,64.599999999996,31.8)); +#8835 = VECTOR('',#8836,1.); +#8836 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8837 = PCURVE('',#3276,#8838); +#8838 = DEFINITIONAL_REPRESENTATION('',(#8839),#8843); +#8839 = LINE('',#8840,#8841); +#8840 = CARTESIAN_POINT('',(-26.84999999998,13.650000000013)); +#8841 = VECTOR('',#8842,1.); +#8842 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8843 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8844 = PCURVE('',#8845,#8850); +#8845 = PLANE('',#8846); +#8846 = AXIS2_PLACEMENT_3D('',#8847,#8848,#8849); +#8847 = CARTESIAN_POINT('',(4.149999999975,64.599999999996,31.8)); +#8848 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#8849 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8850 = DEFINITIONAL_REPRESENTATION('',(#8851),#8855); +#8851 = LINE('',#8852,#8853); +#8852 = CARTESIAN_POINT('',(0.,0.)); +#8853 = VECTOR('',#8854,1.); +#8854 = DIRECTION('',(1.,-4.361251546428E-31)); +#8855 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8856 = FACE_BOUND('',#8857,.T.); +#8857 = EDGE_LOOP('',(#8858,#8888,#8916,#8944)); +#8858 = ORIENTED_EDGE('',*,*,#8859,.T.); +#8859 = EDGE_CURVE('',#8860,#8862,#8864,.T.); +#8860 = VERTEX_POINT('',#8861); +#8861 = CARTESIAN_POINT('',(-7.550000000025,64.599999999996,31.5)); +#8862 = VERTEX_POINT('',#8863); +#8863 = CARTESIAN_POINT('',(-10.55000000002,64.599999999996,31.5)); +#8864 = SURFACE_CURVE('',#8865,(#8869,#8876),.PCURVE_S1.); +#8865 = LINE('',#8866,#8867); +#8866 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8867 = VECTOR('',#8868,1.); +#8868 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8869 = PCURVE('',#3276,#8870); +#8870 = DEFINITIONAL_REPRESENTATION('',(#8871),#8875); +#8871 = LINE('',#8872,#8873); +#8872 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8873 = VECTOR('',#8874,1.); +#8874 = DIRECTION('',(1.,0.)); +#8875 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8876 = PCURVE('',#8877,#8882); +#8877 = PLANE('',#8878); +#8878 = AXIS2_PLACEMENT_3D('',#8879,#8880,#8881); +#8879 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8880 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#8881 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8882 = DEFINITIONAL_REPRESENTATION('',(#8883),#8887); +#8883 = LINE('',#8884,#8885); +#8884 = CARTESIAN_POINT('',(0.,0.)); +#8885 = VECTOR('',#8886,1.); +#8886 = DIRECTION('',(-1.,1.62688410619E-44)); +#8887 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8888 = ORIENTED_EDGE('',*,*,#8889,.T.); +#8889 = EDGE_CURVE('',#8862,#8890,#8892,.T.); +#8890 = VERTEX_POINT('',#8891); +#8891 = CARTESIAN_POINT('',(9.449999999974,64.599999999996,11.5)); +#8892 = SURFACE_CURVE('',#8893,(#8897,#8904),.PCURVE_S1.); +#8893 = LINE('',#8894,#8895); +#8894 = CARTESIAN_POINT('',(-10.85000000002,64.599999999996,31.8)); +#8895 = VECTOR('',#8896,1.); +#8896 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8897 = PCURVE('',#3276,#8898); +#8898 = DEFINITIONAL_REPRESENTATION('',(#8899),#8903); +#8899 = LINE('',#8900,#8901); +#8900 = CARTESIAN_POINT('',(-11.84999999998,13.650000000013)); +#8901 = VECTOR('',#8902,1.); +#8902 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8903 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8904 = PCURVE('',#8905,#8910); +#8905 = PLANE('',#8906); +#8906 = AXIS2_PLACEMENT_3D('',#8907,#8908,#8909); +#8907 = CARTESIAN_POINT('',(14.449999999986,64.599999999996, + 6.499999999988)); +#8908 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#8909 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#8910 = DEFINITIONAL_REPRESENTATION('',(#8911),#8915); +#8911 = LINE('',#8912,#8913); +#8912 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#8913 = VECTOR('',#8914,1.); +#8914 = DIRECTION('',(-1.,-3.871099052181E-31)); +#8915 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8916 = ORIENTED_EDGE('',*,*,#8917,.T.); +#8917 = EDGE_CURVE('',#8890,#8918,#8920,.T.); +#8918 = VERTEX_POINT('',#8919); +#8919 = CARTESIAN_POINT('',(12.449999999975,64.599999999996,11.5)); +#8920 = SURFACE_CURVE('',#8921,(#8925,#8932),.PCURVE_S1.); +#8921 = LINE('',#8922,#8923); +#8922 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#8923 = VECTOR('',#8924,1.); +#8924 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8925 = PCURVE('',#3276,#8926); +#8926 = DEFINITIONAL_REPRESENTATION('',(#8927),#8931); +#8927 = LINE('',#8928,#8929); +#8928 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#8929 = VECTOR('',#8930,1.); +#8930 = DIRECTION('',(-1.,0.)); +#8931 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8932 = PCURVE('',#8933,#8938); +#8933 = PLANE('',#8934); +#8934 = AXIS2_PLACEMENT_3D('',#8935,#8936,#8937); +#8935 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#8936 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#8937 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8938 = DEFINITIONAL_REPRESENTATION('',(#8939),#8943); +#8939 = LINE('',#8940,#8941); +#8940 = CARTESIAN_POINT('',(0.,0.)); +#8941 = VECTOR('',#8942,1.); +#8942 = DIRECTION('',(-1.,-1.62688410619E-44)); +#8943 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8944 = ORIENTED_EDGE('',*,*,#8945,.F.); +#8945 = EDGE_CURVE('',#8860,#8918,#8946,.T.); +#8946 = SURFACE_CURVE('',#8947,(#8951,#8958),.PCURVE_S1.); +#8947 = LINE('',#8948,#8949); +#8948 = CARTESIAN_POINT('',(-7.850000000025,64.599999999996,31.8)); +#8949 = VECTOR('',#8950,1.); +#8950 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8951 = PCURVE('',#3276,#8952); +#8952 = DEFINITIONAL_REPRESENTATION('',(#8953),#8957); +#8953 = LINE('',#8954,#8955); +#8954 = CARTESIAN_POINT('',(-14.84999999998,13.650000000013)); +#8955 = VECTOR('',#8956,1.); +#8956 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#8957 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8958 = PCURVE('',#8959,#8964); +#8959 = PLANE('',#8960); +#8960 = AXIS2_PLACEMENT_3D('',#8961,#8962,#8963); +#8961 = CARTESIAN_POINT('',(-7.850000000025,64.599999999996,31.8)); +#8962 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#8963 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#8964 = DEFINITIONAL_REPRESENTATION('',(#8965),#8969); +#8965 = LINE('',#8966,#8967); +#8966 = CARTESIAN_POINT('',(0.,0.)); +#8967 = VECTOR('',#8968,1.); +#8968 = DIRECTION('',(1.,-4.361251546428E-31)); +#8969 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8970 = FACE_BOUND('',#8971,.T.); +#8971 = EDGE_LOOP('',(#8972,#9002,#9030,#9058)); +#8972 = ORIENTED_EDGE('',*,*,#8973,.T.); +#8973 = EDGE_CURVE('',#8974,#8976,#8978,.T.); +#8974 = VERTEX_POINT('',#8975); +#8975 = CARTESIAN_POINT('',(-19.55000000002,64.599999999996,31.5)); +#8976 = VERTEX_POINT('',#8977); +#8977 = CARTESIAN_POINT('',(-22.55000000002,64.599999999996,31.5)); +#8978 = SURFACE_CURVE('',#8979,(#8983,#8990),.PCURVE_S1.); +#8979 = LINE('',#8980,#8981); +#8980 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8981 = VECTOR('',#8982,1.); +#8982 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#8983 = PCURVE('',#3276,#8984); +#8984 = DEFINITIONAL_REPRESENTATION('',(#8985),#8989); +#8985 = LINE('',#8986,#8987); +#8986 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#8987 = VECTOR('',#8988,1.); +#8988 = DIRECTION('',(1.,0.)); +#8989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#8990 = PCURVE('',#8991,#8996); +#8991 = PLANE('',#8992); +#8992 = AXIS2_PLACEMENT_3D('',#8993,#8994,#8995); +#8993 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#8994 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#8995 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#8996 = DEFINITIONAL_REPRESENTATION('',(#8997),#9001); +#8997 = LINE('',#8998,#8999); +#8998 = CARTESIAN_POINT('',(0.,0.)); +#8999 = VECTOR('',#9000,1.); +#9000 = DIRECTION('',(-1.,1.62688410619E-44)); +#9001 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9002 = ORIENTED_EDGE('',*,*,#9003,.T.); +#9003 = EDGE_CURVE('',#8976,#9004,#9006,.T.); +#9004 = VERTEX_POINT('',#9005); +#9005 = CARTESIAN_POINT('',(-2.550000000026,64.599999999996,11.5)); +#9006 = SURFACE_CURVE('',#9007,(#9011,#9018),.PCURVE_S1.); +#9007 = LINE('',#9008,#9009); +#9008 = CARTESIAN_POINT('',(-22.85000000002,64.599999999996,31.8)); +#9009 = VECTOR('',#9010,1.); +#9010 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9011 = PCURVE('',#3276,#9012); +#9012 = DEFINITIONAL_REPRESENTATION('',(#9013),#9017); +#9013 = LINE('',#9014,#9015); +#9014 = CARTESIAN_POINT('',(0.150000000011,13.650000000013)); +#9015 = VECTOR('',#9016,1.); +#9016 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9017 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9018 = PCURVE('',#9019,#9024); +#9019 = PLANE('',#9020); +#9020 = AXIS2_PLACEMENT_3D('',#9021,#9022,#9023); +#9021 = CARTESIAN_POINT('',(2.449999999986,64.599999999996, + 6.499999999988)); +#9022 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9023 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9024 = DEFINITIONAL_REPRESENTATION('',(#9025),#9029); +#9025 = LINE('',#9026,#9027); +#9026 = CARTESIAN_POINT('',(35.779603128055,-7.34651991656E-14)); +#9027 = VECTOR('',#9028,1.); +#9028 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9029 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9030 = ORIENTED_EDGE('',*,*,#9031,.T.); +#9031 = EDGE_CURVE('',#9004,#9032,#9034,.T.); +#9032 = VERTEX_POINT('',#9033); +#9033 = CARTESIAN_POINT('',(0.449999999975,64.599999999996,11.5)); +#9034 = SURFACE_CURVE('',#9035,(#9039,#9046),.PCURVE_S1.); +#9035 = LINE('',#9036,#9037); +#9036 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9037 = VECTOR('',#9038,1.); +#9038 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9039 = PCURVE('',#3276,#9040); +#9040 = DEFINITIONAL_REPRESENTATION('',(#9041),#9045); +#9041 = LINE('',#9042,#9043); +#9042 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9043 = VECTOR('',#9044,1.); +#9044 = DIRECTION('',(-1.,0.)); +#9045 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9046 = PCURVE('',#9047,#9052); +#9047 = PLANE('',#9048); +#9048 = AXIS2_PLACEMENT_3D('',#9049,#9050,#9051); +#9049 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9050 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9051 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9052 = DEFINITIONAL_REPRESENTATION('',(#9053),#9057); +#9053 = LINE('',#9054,#9055); +#9054 = CARTESIAN_POINT('',(0.,0.)); +#9055 = VECTOR('',#9056,1.); +#9056 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9057 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9058 = ORIENTED_EDGE('',*,*,#9059,.F.); +#9059 = EDGE_CURVE('',#8974,#9032,#9060,.T.); +#9060 = SURFACE_CURVE('',#9061,(#9065,#9072),.PCURVE_S1.); +#9061 = LINE('',#9062,#9063); +#9062 = CARTESIAN_POINT('',(-19.85000000002,64.599999999996,31.8)); +#9063 = VECTOR('',#9064,1.); +#9064 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9065 = PCURVE('',#3276,#9066); +#9066 = DEFINITIONAL_REPRESENTATION('',(#9067),#9071); +#9067 = LINE('',#9068,#9069); +#9068 = CARTESIAN_POINT('',(-2.849999999989,13.650000000013)); +#9069 = VECTOR('',#9070,1.); +#9070 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9071 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9072 = PCURVE('',#9073,#9078); +#9073 = PLANE('',#9074); +#9074 = AXIS2_PLACEMENT_3D('',#9075,#9076,#9077); +#9075 = CARTESIAN_POINT('',(-19.85000000002,64.599999999996,31.8)); +#9076 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9077 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9078 = DEFINITIONAL_REPRESENTATION('',(#9079),#9083); +#9079 = LINE('',#9080,#9081); +#9080 = CARTESIAN_POINT('',(0.,0.)); +#9081 = VECTOR('',#9082,1.); +#9082 = DIRECTION('',(1.,-4.361251546428E-31)); +#9083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9084 = FACE_BOUND('',#9085,.T.); +#9085 = EDGE_LOOP('',(#9086,#9116,#9144,#9172)); +#9086 = ORIENTED_EDGE('',*,*,#9087,.T.); +#9087 = EDGE_CURVE('',#9088,#9090,#9092,.T.); +#9088 = VERTEX_POINT('',#9089); +#9089 = CARTESIAN_POINT('',(-26.,64.599999999996,25.949999999979)); +#9090 = VERTEX_POINT('',#9091); +#9091 = CARTESIAN_POINT('',(-26.,64.599999999996,22.949999999979)); +#9092 = SURFACE_CURVE('',#9093,(#9097,#9104),.PCURVE_S1.); +#9093 = LINE('',#9094,#9095); +#9094 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9095 = VECTOR('',#9096,1.); +#9096 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9097 = PCURVE('',#3276,#9098); +#9098 = DEFINITIONAL_REPRESENTATION('',(#9099),#9103); +#9099 = LINE('',#9100,#9101); +#9100 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#9101 = VECTOR('',#9102,1.); +#9102 = DIRECTION('',(0.,-1.)); +#9103 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9104 = PCURVE('',#9105,#9110); +#9105 = PLANE('',#9106); +#9106 = AXIS2_PLACEMENT_3D('',#9107,#9108,#9109); +#9107 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9108 = DIRECTION('',(1.,4.440892098501E-15,-6.710814671636E-29)); +#9109 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9110 = DEFINITIONAL_REPRESENTATION('',(#9111),#9115); +#9111 = LINE('',#9112,#9113); +#9112 = CARTESIAN_POINT('',(0.,0.)); +#9113 = VECTOR('',#9114,1.); +#9114 = DIRECTION('',(-1.,3.944304526105E-31)); +#9115 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9116 = ORIENTED_EDGE('',*,*,#9117,.T.); +#9117 = EDGE_CURVE('',#9090,#9118,#9120,.T.); +#9118 = VERTEX_POINT('',#9119); +#9119 = CARTESIAN_POINT('',(-14.55000000002,64.599999999996,11.5)); +#9120 = SURFACE_CURVE('',#9121,(#9125,#9132),.PCURVE_S1.); +#9121 = LINE('',#9122,#9123); +#9122 = CARTESIAN_POINT('',(-34.85000000002,64.599999999996,31.8)); +#9123 = VECTOR('',#9124,1.); +#9124 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9125 = PCURVE('',#3276,#9126); +#9126 = DEFINITIONAL_REPRESENTATION('',(#9127),#9131); +#9127 = LINE('',#9128,#9129); +#9128 = CARTESIAN_POINT('',(12.150000000011,13.650000000013)); +#9129 = VECTOR('',#9130,1.); +#9130 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9131 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9132 = PCURVE('',#9133,#9138); +#9133 = PLANE('',#9134); +#9134 = AXIS2_PLACEMENT_3D('',#9135,#9136,#9137); +#9135 = CARTESIAN_POINT('',(-9.550000000014,64.599999999996, + 6.499999999988)); +#9136 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9137 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9138 = DEFINITIONAL_REPRESENTATION('',(#9139),#9143); +#9139 = LINE('',#9140,#9141); +#9140 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9141 = VECTOR('',#9142,1.); +#9142 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9143 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9144 = ORIENTED_EDGE('',*,*,#9145,.T.); +#9145 = EDGE_CURVE('',#9118,#9146,#9148,.T.); +#9146 = VERTEX_POINT('',#9147); +#9147 = CARTESIAN_POINT('',(-11.55000000002,64.599999999996,11.5)); +#9148 = SURFACE_CURVE('',#9149,(#9153,#9160),.PCURVE_S1.); +#9149 = LINE('',#9150,#9151); +#9150 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9151 = VECTOR('',#9152,1.); +#9152 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9153 = PCURVE('',#3276,#9154); +#9154 = DEFINITIONAL_REPRESENTATION('',(#9155),#9159); +#9155 = LINE('',#9156,#9157); +#9156 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9157 = VECTOR('',#9158,1.); +#9158 = DIRECTION('',(-1.,0.)); +#9159 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9160 = PCURVE('',#9161,#9166); +#9161 = PLANE('',#9162); +#9162 = AXIS2_PLACEMENT_3D('',#9163,#9164,#9165); +#9163 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9164 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9165 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9166 = DEFINITIONAL_REPRESENTATION('',(#9167),#9171); +#9167 = LINE('',#9168,#9169); +#9168 = CARTESIAN_POINT('',(0.,0.)); +#9169 = VECTOR('',#9170,1.); +#9170 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9171 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9172 = ORIENTED_EDGE('',*,*,#9173,.F.); +#9173 = EDGE_CURVE('',#9088,#9146,#9174,.T.); +#9174 = SURFACE_CURVE('',#9175,(#9179,#9186),.PCURVE_S1.); +#9175 = LINE('',#9176,#9177); +#9176 = CARTESIAN_POINT('',(-31.85000000002,64.599999999996,31.8)); +#9177 = VECTOR('',#9178,1.); +#9178 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9179 = PCURVE('',#3276,#9180); +#9180 = DEFINITIONAL_REPRESENTATION('',(#9181),#9185); +#9181 = LINE('',#9182,#9183); +#9182 = CARTESIAN_POINT('',(9.150000000011,13.650000000013)); +#9183 = VECTOR('',#9184,1.); +#9184 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9185 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9186 = PCURVE('',#9187,#9192); +#9187 = PLANE('',#9188); +#9188 = AXIS2_PLACEMENT_3D('',#9189,#9190,#9191); +#9189 = CARTESIAN_POINT('',(-31.85000000002,64.599999999996,31.8)); +#9190 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9191 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9192 = DEFINITIONAL_REPRESENTATION('',(#9193),#9197); +#9193 = LINE('',#9194,#9195); +#9194 = CARTESIAN_POINT('',(0.,0.)); +#9195 = VECTOR('',#9196,1.); +#9196 = DIRECTION('',(1.,-4.361251546428E-31)); +#9197 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9198 = FACE_BOUND('',#9199,.T.); +#9199 = EDGE_LOOP('',(#9200,#9230,#9258)); +#9200 = ORIENTED_EDGE('',*,*,#9201,.T.); +#9201 = EDGE_CURVE('',#9202,#9204,#9206,.T.); +#9202 = VERTEX_POINT('',#9203); +#9203 = CARTESIAN_POINT('',(-26.,64.599999999996,13.949999999979)); +#9204 = VERTEX_POINT('',#9205); +#9205 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9206 = SURFACE_CURVE('',#9207,(#9211,#9218),.PCURVE_S1.); +#9207 = LINE('',#9208,#9209); +#9208 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9209 = VECTOR('',#9210,1.); +#9210 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9211 = PCURVE('',#3276,#9212); +#9212 = DEFINITIONAL_REPRESENTATION('',(#9213),#9217); +#9213 = LINE('',#9214,#9215); +#9214 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#9215 = VECTOR('',#9216,1.); +#9216 = DIRECTION('',(0.,-1.)); +#9217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9218 = PCURVE('',#9219,#9224); +#9219 = PLANE('',#9220); +#9220 = AXIS2_PLACEMENT_3D('',#9221,#9222,#9223); +#9221 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9222 = DIRECTION('',(1.,4.440892098501E-15,-6.710814671636E-29)); +#9223 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9224 = DEFINITIONAL_REPRESENTATION('',(#9225),#9229); +#9225 = LINE('',#9226,#9227); +#9226 = CARTESIAN_POINT('',(0.,0.)); +#9227 = VECTOR('',#9228,1.); +#9228 = DIRECTION('',(-1.,3.944304526105E-31)); +#9229 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9230 = ORIENTED_EDGE('',*,*,#9231,.T.); +#9231 = EDGE_CURVE('',#9204,#9232,#9234,.T.); +#9232 = VERTEX_POINT('',#9233); +#9233 = CARTESIAN_POINT('',(-23.55000000002,64.599999999996,11.5)); +#9234 = SURFACE_CURVE('',#9235,(#9239,#9246),.PCURVE_S1.); +#9235 = LINE('',#9236,#9237); +#9236 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9237 = VECTOR('',#9238,1.); +#9238 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9239 = PCURVE('',#3276,#9240); +#9240 = DEFINITIONAL_REPRESENTATION('',(#9241),#9245); +#9241 = LINE('',#9242,#9243); +#9242 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9243 = VECTOR('',#9244,1.); +#9244 = DIRECTION('',(-1.,0.)); +#9245 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9246 = PCURVE('',#9247,#9252); +#9247 = PLANE('',#9248); +#9248 = AXIS2_PLACEMENT_3D('',#9249,#9250,#9251); +#9249 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9250 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9251 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9252 = DEFINITIONAL_REPRESENTATION('',(#9253),#9257); +#9253 = LINE('',#9254,#9255); +#9254 = CARTESIAN_POINT('',(0.,0.)); +#9255 = VECTOR('',#9256,1.); +#9256 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9257 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9258 = ORIENTED_EDGE('',*,*,#9259,.F.); +#9259 = EDGE_CURVE('',#9202,#9232,#9260,.T.); +#9260 = SURFACE_CURVE('',#9261,(#9265,#9272),.PCURVE_S1.); +#9261 = LINE('',#9262,#9263); +#9262 = CARTESIAN_POINT('',(-43.85000000002,64.599999999996,31.8)); +#9263 = VECTOR('',#9264,1.); +#9264 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9265 = PCURVE('',#3276,#9266); +#9266 = DEFINITIONAL_REPRESENTATION('',(#9267),#9271); +#9267 = LINE('',#9268,#9269); +#9268 = CARTESIAN_POINT('',(21.150000000011,13.650000000013)); +#9269 = VECTOR('',#9270,1.); +#9270 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9271 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9272 = PCURVE('',#9273,#9278); +#9273 = PLANE('',#9274); +#9274 = AXIS2_PLACEMENT_3D('',#9275,#9276,#9277); +#9275 = CARTESIAN_POINT('',(-43.85000000002,64.599999999996,31.8)); +#9276 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9277 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9278 = DEFINITIONAL_REPRESENTATION('',(#9279),#9283); +#9279 = LINE('',#9280,#9281); +#9280 = CARTESIAN_POINT('',(0.,0.)); +#9281 = VECTOR('',#9282,1.); +#9282 = DIRECTION('',(1.,-4.361251546428E-31)); +#9283 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9284 = FACE_BOUND('',#9285,.T.); +#9285 = EDGE_LOOP('',(#9286,#9316,#9344,#9372)); +#9286 = ORIENTED_EDGE('',*,*,#9287,.T.); +#9287 = EDGE_CURVE('',#9288,#9290,#9292,.T.); +#9288 = VERTEX_POINT('',#9289); +#9289 = CARTESIAN_POINT('',(-26.,64.599999999996,19.949999999979)); +#9290 = VERTEX_POINT('',#9291); +#9291 = CARTESIAN_POINT('',(-26.,64.599999999996,16.949999999979)); +#9292 = SURFACE_CURVE('',#9293,(#9297,#9304),.PCURVE_S1.); +#9293 = LINE('',#9294,#9295); +#9294 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9295 = VECTOR('',#9296,1.); +#9296 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9297 = PCURVE('',#3276,#9298); +#9298 = DEFINITIONAL_REPRESENTATION('',(#9299),#9303); +#9299 = LINE('',#9300,#9301); +#9300 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#9301 = VECTOR('',#9302,1.); +#9302 = DIRECTION('',(0.,-1.)); +#9303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9304 = PCURVE('',#9305,#9310); +#9305 = PLANE('',#9306); +#9306 = AXIS2_PLACEMENT_3D('',#9307,#9308,#9309); +#9307 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9308 = DIRECTION('',(1.,4.440892098501E-15,-6.710814671636E-29)); +#9309 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9310 = DEFINITIONAL_REPRESENTATION('',(#9311),#9315); +#9311 = LINE('',#9312,#9313); +#9312 = CARTESIAN_POINT('',(0.,0.)); +#9313 = VECTOR('',#9314,1.); +#9314 = DIRECTION('',(-1.,3.944304526105E-31)); +#9315 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9316 = ORIENTED_EDGE('',*,*,#9317,.T.); +#9317 = EDGE_CURVE('',#9290,#9318,#9320,.T.); +#9318 = VERTEX_POINT('',#9319); +#9319 = CARTESIAN_POINT('',(-20.55000000002,64.599999999996,11.5)); +#9320 = SURFACE_CURVE('',#9321,(#9325,#9332),.PCURVE_S1.); +#9321 = LINE('',#9322,#9323); +#9322 = CARTESIAN_POINT('',(-40.85000000002,64.599999999996,31.8)); +#9323 = VECTOR('',#9324,1.); +#9324 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9325 = PCURVE('',#3276,#9326); +#9326 = DEFINITIONAL_REPRESENTATION('',(#9327),#9331); +#9327 = LINE('',#9328,#9329); +#9328 = CARTESIAN_POINT('',(18.150000000011,13.650000000013)); +#9329 = VECTOR('',#9330,1.); +#9330 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9332 = PCURVE('',#9333,#9338); +#9333 = PLANE('',#9334); +#9334 = AXIS2_PLACEMENT_3D('',#9335,#9336,#9337); +#9335 = CARTESIAN_POINT('',(-15.55000000001,64.599999999996, + 6.499999999988)); +#9336 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9337 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9338 = DEFINITIONAL_REPRESENTATION('',(#9339),#9343); +#9339 = LINE('',#9340,#9341); +#9340 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9341 = VECTOR('',#9342,1.); +#9342 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9343 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9344 = ORIENTED_EDGE('',*,*,#9345,.T.); +#9345 = EDGE_CURVE('',#9318,#9346,#9348,.T.); +#9346 = VERTEX_POINT('',#9347); +#9347 = CARTESIAN_POINT('',(-17.55000000002,64.599999999996,11.5)); +#9348 = SURFACE_CURVE('',#9349,(#9353,#9360),.PCURVE_S1.); +#9349 = LINE('',#9350,#9351); +#9350 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9351 = VECTOR('',#9352,1.); +#9352 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9353 = PCURVE('',#3276,#9354); +#9354 = DEFINITIONAL_REPRESENTATION('',(#9355),#9359); +#9355 = LINE('',#9356,#9357); +#9356 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9357 = VECTOR('',#9358,1.); +#9358 = DIRECTION('',(-1.,0.)); +#9359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9360 = PCURVE('',#9361,#9366); +#9361 = PLANE('',#9362); +#9362 = AXIS2_PLACEMENT_3D('',#9363,#9364,#9365); +#9363 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9364 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9365 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9366 = DEFINITIONAL_REPRESENTATION('',(#9367),#9371); +#9367 = LINE('',#9368,#9369); +#9368 = CARTESIAN_POINT('',(0.,0.)); +#9369 = VECTOR('',#9370,1.); +#9370 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9371 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9372 = ORIENTED_EDGE('',*,*,#9373,.F.); +#9373 = EDGE_CURVE('',#9288,#9346,#9374,.T.); +#9374 = SURFACE_CURVE('',#9375,(#9379,#9386),.PCURVE_S1.); +#9375 = LINE('',#9376,#9377); +#9376 = CARTESIAN_POINT('',(-37.85000000002,64.599999999996,31.8)); +#9377 = VECTOR('',#9378,1.); +#9378 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9379 = PCURVE('',#3276,#9380); +#9380 = DEFINITIONAL_REPRESENTATION('',(#9381),#9385); +#9381 = LINE('',#9382,#9383); +#9382 = CARTESIAN_POINT('',(15.150000000011,13.650000000013)); +#9383 = VECTOR('',#9384,1.); +#9384 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9386 = PCURVE('',#9387,#9392); +#9387 = PLANE('',#9388); +#9388 = AXIS2_PLACEMENT_3D('',#9389,#9390,#9391); +#9389 = CARTESIAN_POINT('',(-37.85000000002,64.599999999996,31.8)); +#9390 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9391 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9392 = DEFINITIONAL_REPRESENTATION('',(#9393),#9397); +#9393 = LINE('',#9394,#9395); +#9394 = CARTESIAN_POINT('',(0.,0.)); +#9395 = VECTOR('',#9396,1.); +#9396 = DIRECTION('',(1.,-4.361251546428E-31)); +#9397 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9398 = FACE_BOUND('',#9399,.T.); +#9399 = EDGE_LOOP('',(#9400,#9430,#9458,#9486,#9514)); +#9400 = ORIENTED_EDGE('',*,*,#9401,.T.); +#9401 = EDGE_CURVE('',#9402,#9404,#9406,.T.); +#9402 = VERTEX_POINT('',#9403); +#9403 = CARTESIAN_POINT('',(-25.55000000002,64.599999999996,31.5)); +#9404 = VERTEX_POINT('',#9405); +#9405 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9406 = SURFACE_CURVE('',#9407,(#9411,#9418),.PCURVE_S1.); +#9407 = LINE('',#9408,#9409); +#9408 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9409 = VECTOR('',#9410,1.); +#9410 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9411 = PCURVE('',#3276,#9412); +#9412 = DEFINITIONAL_REPRESENTATION('',(#9413),#9417); +#9413 = LINE('',#9414,#9415); +#9414 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#9415 = VECTOR('',#9416,1.); +#9416 = DIRECTION('',(1.,0.)); +#9417 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9418 = PCURVE('',#9419,#9424); +#9419 = PLANE('',#9420); +#9420 = AXIS2_PLACEMENT_3D('',#9421,#9422,#9423); +#9421 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9422 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#9423 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9424 = DEFINITIONAL_REPRESENTATION('',(#9425),#9429); +#9425 = LINE('',#9426,#9427); +#9426 = CARTESIAN_POINT('',(0.,0.)); +#9427 = VECTOR('',#9428,1.); +#9428 = DIRECTION('',(-1.,1.62688410619E-44)); +#9429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9430 = ORIENTED_EDGE('',*,*,#9431,.T.); +#9431 = EDGE_CURVE('',#9404,#9432,#9434,.T.); +#9432 = VERTEX_POINT('',#9433); +#9433 = CARTESIAN_POINT('',(-26.,64.599999999996,28.949999999979)); +#9434 = SURFACE_CURVE('',#9435,(#9439,#9446),.PCURVE_S1.); +#9435 = LINE('',#9436,#9437); +#9436 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9437 = VECTOR('',#9438,1.); +#9438 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9439 = PCURVE('',#3276,#9440); +#9440 = DEFINITIONAL_REPRESENTATION('',(#9441),#9445); +#9441 = LINE('',#9442,#9443); +#9442 = CARTESIAN_POINT('',(3.29999999999,-6.649999999987)); +#9443 = VECTOR('',#9444,1.); +#9444 = DIRECTION('',(0.,-1.)); +#9445 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9446 = PCURVE('',#9447,#9452); +#9447 = PLANE('',#9448); +#9448 = AXIS2_PLACEMENT_3D('',#9449,#9450,#9451); +#9449 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#9450 = DIRECTION('',(1.,4.440892098501E-15,-6.710814671636E-29)); +#9451 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9452 = DEFINITIONAL_REPRESENTATION('',(#9453),#9457); +#9453 = LINE('',#9454,#9455); +#9454 = CARTESIAN_POINT('',(0.,0.)); +#9455 = VECTOR('',#9456,1.); +#9456 = DIRECTION('',(-1.,3.944304526105E-31)); +#9457 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9458 = ORIENTED_EDGE('',*,*,#9459,.T.); +#9459 = EDGE_CURVE('',#9432,#9460,#9462,.T.); +#9460 = VERTEX_POINT('',#9461); +#9461 = CARTESIAN_POINT('',(-8.550000000026,64.599999999996,11.5)); +#9462 = SURFACE_CURVE('',#9463,(#9467,#9474),.PCURVE_S1.); +#9463 = LINE('',#9464,#9465); +#9464 = CARTESIAN_POINT('',(-28.85000000002,64.599999999996,31.8)); +#9465 = VECTOR('',#9466,1.); +#9466 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9467 = PCURVE('',#3276,#9468); +#9468 = DEFINITIONAL_REPRESENTATION('',(#9469),#9473); +#9469 = LINE('',#9470,#9471); +#9470 = CARTESIAN_POINT('',(6.150000000011,13.650000000013)); +#9471 = VECTOR('',#9472,1.); +#9472 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9473 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9474 = PCURVE('',#9475,#9480); +#9475 = PLANE('',#9476); +#9476 = AXIS2_PLACEMENT_3D('',#9477,#9478,#9479); +#9477 = CARTESIAN_POINT('',(-3.550000000014,64.599999999996, + 6.499999999988)); +#9478 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9479 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9480 = DEFINITIONAL_REPRESENTATION('',(#9481),#9485); +#9481 = LINE('',#9482,#9483); +#9482 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9483 = VECTOR('',#9484,1.); +#9484 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9485 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9486 = ORIENTED_EDGE('',*,*,#9487,.T.); +#9487 = EDGE_CURVE('',#9460,#9488,#9490,.T.); +#9488 = VERTEX_POINT('',#9489); +#9489 = CARTESIAN_POINT('',(-5.550000000025,64.599999999996,11.5)); +#9490 = SURFACE_CURVE('',#9491,(#9495,#9502),.PCURVE_S1.); +#9491 = LINE('',#9492,#9493); +#9492 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9493 = VECTOR('',#9494,1.); +#9494 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9495 = PCURVE('',#3276,#9496); +#9496 = DEFINITIONAL_REPRESENTATION('',(#9497),#9501); +#9497 = LINE('',#9498,#9499); +#9498 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9499 = VECTOR('',#9500,1.); +#9500 = DIRECTION('',(-1.,0.)); +#9501 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9502 = PCURVE('',#9503,#9508); +#9503 = PLANE('',#9504); +#9504 = AXIS2_PLACEMENT_3D('',#9505,#9506,#9507); +#9505 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9506 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9507 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9508 = DEFINITIONAL_REPRESENTATION('',(#9509),#9513); +#9509 = LINE('',#9510,#9511); +#9510 = CARTESIAN_POINT('',(0.,0.)); +#9511 = VECTOR('',#9512,1.); +#9512 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9513 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9514 = ORIENTED_EDGE('',*,*,#9515,.F.); +#9515 = EDGE_CURVE('',#9402,#9488,#9516,.T.); +#9516 = SURFACE_CURVE('',#9517,(#9521,#9528),.PCURVE_S1.); +#9517 = LINE('',#9518,#9519); +#9518 = CARTESIAN_POINT('',(-25.85000000002,64.599999999996,31.8)); +#9519 = VECTOR('',#9520,1.); +#9520 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9521 = PCURVE('',#3276,#9522); +#9522 = DEFINITIONAL_REPRESENTATION('',(#9523),#9527); +#9523 = LINE('',#9524,#9525); +#9524 = CARTESIAN_POINT('',(3.150000000011,13.650000000013)); +#9525 = VECTOR('',#9526,1.); +#9526 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9527 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9528 = PCURVE('',#9529,#9534); +#9529 = PLANE('',#9530); +#9530 = AXIS2_PLACEMENT_3D('',#9531,#9532,#9533); +#9531 = CARTESIAN_POINT('',(-25.85000000002,64.599999999996,31.8)); +#9532 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9533 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9534 = DEFINITIONAL_REPRESENTATION('',(#9535),#9539); +#9535 = LINE('',#9536,#9537); +#9536 = CARTESIAN_POINT('',(0.,0.)); +#9537 = VECTOR('',#9538,1.); +#9538 = DIRECTION('',(1.,-4.361251546428E-31)); +#9539 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9540 = FACE_BOUND('',#9541,.T.); +#9541 = EDGE_LOOP('',(#9542,#9572,#9600,#9628)); +#9542 = ORIENTED_EDGE('',*,*,#9543,.T.); +#9543 = EDGE_CURVE('',#9544,#9546,#9548,.T.); +#9544 = VERTEX_POINT('',#9545); +#9545 = CARTESIAN_POINT('',(-13.55000000002,64.599999999996,31.5)); +#9546 = VERTEX_POINT('',#9547); +#9547 = CARTESIAN_POINT('',(-16.55000000002,64.599999999996,31.5)); +#9548 = SURFACE_CURVE('',#9549,(#9553,#9560),.PCURVE_S1.); +#9549 = LINE('',#9550,#9551); +#9550 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9551 = VECTOR('',#9552,1.); +#9552 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9553 = PCURVE('',#3276,#9554); +#9554 = DEFINITIONAL_REPRESENTATION('',(#9555),#9559); +#9555 = LINE('',#9556,#9557); +#9556 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#9557 = VECTOR('',#9558,1.); +#9558 = DIRECTION('',(1.,0.)); +#9559 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9560 = PCURVE('',#9561,#9566); +#9561 = PLANE('',#9562); +#9562 = AXIS2_PLACEMENT_3D('',#9563,#9564,#9565); +#9563 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9564 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#9565 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9566 = DEFINITIONAL_REPRESENTATION('',(#9567),#9571); +#9567 = LINE('',#9568,#9569); +#9568 = CARTESIAN_POINT('',(0.,0.)); +#9569 = VECTOR('',#9570,1.); +#9570 = DIRECTION('',(-1.,1.62688410619E-44)); +#9571 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9572 = ORIENTED_EDGE('',*,*,#9573,.T.); +#9573 = EDGE_CURVE('',#9546,#9574,#9576,.T.); +#9574 = VERTEX_POINT('',#9575); +#9575 = CARTESIAN_POINT('',(3.449999999974,64.599999999996,11.5)); +#9576 = SURFACE_CURVE('',#9577,(#9581,#9588),.PCURVE_S1.); +#9577 = LINE('',#9578,#9579); +#9578 = CARTESIAN_POINT('',(-16.85000000002,64.599999999996,31.8)); +#9579 = VECTOR('',#9580,1.); +#9580 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9581 = PCURVE('',#3276,#9582); +#9582 = DEFINITIONAL_REPRESENTATION('',(#9583),#9587); +#9583 = LINE('',#9584,#9585); +#9584 = CARTESIAN_POINT('',(-5.849999999989,13.650000000013)); +#9585 = VECTOR('',#9586,1.); +#9586 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9588 = PCURVE('',#9589,#9594); +#9589 = PLANE('',#9590); +#9590 = AXIS2_PLACEMENT_3D('',#9591,#9592,#9593); +#9591 = CARTESIAN_POINT('',(8.449999999986,64.599999999996, + 6.499999999988)); +#9592 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9593 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9594 = DEFINITIONAL_REPRESENTATION('',(#9595),#9599); +#9595 = LINE('',#9596,#9597); +#9596 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9597 = VECTOR('',#9598,1.); +#9598 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9600 = ORIENTED_EDGE('',*,*,#9601,.T.); +#9601 = EDGE_CURVE('',#9574,#9602,#9604,.T.); +#9602 = VERTEX_POINT('',#9603); +#9603 = CARTESIAN_POINT('',(6.449999999975,64.599999999996,11.5)); +#9604 = SURFACE_CURVE('',#9605,(#9609,#9616),.PCURVE_S1.); +#9605 = LINE('',#9606,#9607); +#9606 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9607 = VECTOR('',#9608,1.); +#9608 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9609 = PCURVE('',#3276,#9610); +#9610 = DEFINITIONAL_REPRESENTATION('',(#9611),#9615); +#9611 = LINE('',#9612,#9613); +#9612 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9613 = VECTOR('',#9614,1.); +#9614 = DIRECTION('',(-1.,0.)); +#9615 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9616 = PCURVE('',#9617,#9622); +#9617 = PLANE('',#9618); +#9618 = AXIS2_PLACEMENT_3D('',#9619,#9620,#9621); +#9619 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9620 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9621 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9622 = DEFINITIONAL_REPRESENTATION('',(#9623),#9627); +#9623 = LINE('',#9624,#9625); +#9624 = CARTESIAN_POINT('',(0.,0.)); +#9625 = VECTOR('',#9626,1.); +#9626 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9627 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9628 = ORIENTED_EDGE('',*,*,#9629,.F.); +#9629 = EDGE_CURVE('',#9544,#9602,#9630,.T.); +#9630 = SURFACE_CURVE('',#9631,(#9635,#9642),.PCURVE_S1.); +#9631 = LINE('',#9632,#9633); +#9632 = CARTESIAN_POINT('',(-13.85000000002,64.599999999996,31.8)); +#9633 = VECTOR('',#9634,1.); +#9634 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9635 = PCURVE('',#3276,#9636); +#9636 = DEFINITIONAL_REPRESENTATION('',(#9637),#9641); +#9637 = LINE('',#9638,#9639); +#9638 = CARTESIAN_POINT('',(-8.849999999989,13.650000000013)); +#9639 = VECTOR('',#9640,1.); +#9640 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9641 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9642 = PCURVE('',#9643,#9648); +#9643 = PLANE('',#9644); +#9644 = AXIS2_PLACEMENT_3D('',#9645,#9646,#9647); +#9645 = CARTESIAN_POINT('',(-13.85000000002,64.599999999996,31.8)); +#9646 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9647 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9648 = DEFINITIONAL_REPRESENTATION('',(#9649),#9653); +#9649 = LINE('',#9650,#9651); +#9650 = CARTESIAN_POINT('',(0.,0.)); +#9651 = VECTOR('',#9652,1.); +#9652 = DIRECTION('',(1.,-4.361251546428E-31)); +#9653 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9654 = FACE_BOUND('',#9655,.T.); +#9655 = EDGE_LOOP('',(#9656,#9686,#9714,#9742)); +#9656 = ORIENTED_EDGE('',*,*,#9657,.T.); +#9657 = EDGE_CURVE('',#9658,#9660,#9662,.T.); +#9658 = VERTEX_POINT('',#9659); +#9659 = CARTESIAN_POINT('',(-1.550000000025,64.599999999996,31.5)); +#9660 = VERTEX_POINT('',#9661); +#9661 = CARTESIAN_POINT('',(-4.550000000025,64.599999999996,31.5)); +#9662 = SURFACE_CURVE('',#9663,(#9667,#9674),.PCURVE_S1.); +#9663 = LINE('',#9664,#9665); +#9664 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9665 = VECTOR('',#9666,1.); +#9666 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9667 = PCURVE('',#3276,#9668); +#9668 = DEFINITIONAL_REPRESENTATION('',(#9669),#9673); +#9669 = LINE('',#9670,#9671); +#9670 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#9671 = VECTOR('',#9672,1.); +#9672 = DIRECTION('',(1.,0.)); +#9673 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9674 = PCURVE('',#9675,#9680); +#9675 = PLANE('',#9676); +#9676 = AXIS2_PLACEMENT_3D('',#9677,#9678,#9679); +#9677 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9678 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#9679 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9680 = DEFINITIONAL_REPRESENTATION('',(#9681),#9685); +#9681 = LINE('',#9682,#9683); +#9682 = CARTESIAN_POINT('',(0.,0.)); +#9683 = VECTOR('',#9684,1.); +#9684 = DIRECTION('',(-1.,1.62688410619E-44)); +#9685 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9686 = ORIENTED_EDGE('',*,*,#9687,.T.); +#9687 = EDGE_CURVE('',#9660,#9688,#9690,.T.); +#9688 = VERTEX_POINT('',#9689); +#9689 = CARTESIAN_POINT('',(15.449999999974,64.599999999996,11.5)); +#9690 = SURFACE_CURVE('',#9691,(#9695,#9702),.PCURVE_S1.); +#9691 = LINE('',#9692,#9693); +#9692 = CARTESIAN_POINT('',(-4.850000000025,64.599999999996,31.8)); +#9693 = VECTOR('',#9694,1.); +#9694 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9695 = PCURVE('',#3276,#9696); +#9696 = DEFINITIONAL_REPRESENTATION('',(#9697),#9701); +#9697 = LINE('',#9698,#9699); +#9698 = CARTESIAN_POINT('',(-17.84999999998,13.650000000013)); +#9699 = VECTOR('',#9700,1.); +#9700 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9701 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9702 = PCURVE('',#9703,#9708); +#9703 = PLANE('',#9704); +#9704 = AXIS2_PLACEMENT_3D('',#9705,#9706,#9707); +#9705 = CARTESIAN_POINT('',(20.449999999986,64.599999999996, + 6.499999999988)); +#9706 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9707 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9708 = DEFINITIONAL_REPRESENTATION('',(#9709),#9713); +#9709 = LINE('',#9710,#9711); +#9710 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9711 = VECTOR('',#9712,1.); +#9712 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9713 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9714 = ORIENTED_EDGE('',*,*,#9715,.T.); +#9715 = EDGE_CURVE('',#9688,#9716,#9718,.T.); +#9716 = VERTEX_POINT('',#9717); +#9717 = CARTESIAN_POINT('',(18.449999999975,64.599999999996,11.5)); +#9718 = SURFACE_CURVE('',#9719,(#9723,#9730),.PCURVE_S1.); +#9719 = LINE('',#9720,#9721); +#9720 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9721 = VECTOR('',#9722,1.); +#9722 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9723 = PCURVE('',#3276,#9724); +#9724 = DEFINITIONAL_REPRESENTATION('',(#9725),#9729); +#9725 = LINE('',#9726,#9727); +#9726 = CARTESIAN_POINT('',(-44.70000000003,-6.649999999987)); +#9727 = VECTOR('',#9728,1.); +#9728 = DIRECTION('',(-1.,0.)); +#9729 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9730 = PCURVE('',#9731,#9736); +#9731 = PLANE('',#9732); +#9732 = AXIS2_PLACEMENT_3D('',#9733,#9734,#9735); +#9733 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#9734 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#9735 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9736 = DEFINITIONAL_REPRESENTATION('',(#9737),#9741); +#9737 = LINE('',#9738,#9739); +#9738 = CARTESIAN_POINT('',(0.,0.)); +#9739 = VECTOR('',#9740,1.); +#9740 = DIRECTION('',(-1.,-1.62688410619E-44)); +#9741 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9742 = ORIENTED_EDGE('',*,*,#9743,.F.); +#9743 = EDGE_CURVE('',#9658,#9716,#9744,.T.); +#9744 = SURFACE_CURVE('',#9745,(#9749,#9756),.PCURVE_S1.); +#9745 = LINE('',#9746,#9747); +#9746 = CARTESIAN_POINT('',(-1.850000000025,64.599999999996,31.8)); +#9747 = VECTOR('',#9748,1.); +#9748 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9749 = PCURVE('',#3276,#9750); +#9750 = DEFINITIONAL_REPRESENTATION('',(#9751),#9755); +#9751 = LINE('',#9752,#9753); +#9752 = CARTESIAN_POINT('',(-20.84999999998,13.650000000013)); +#9753 = VECTOR('',#9754,1.); +#9754 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9755 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9756 = PCURVE('',#9757,#9762); +#9757 = PLANE('',#9758); +#9758 = AXIS2_PLACEMENT_3D('',#9759,#9760,#9761); +#9759 = CARTESIAN_POINT('',(-1.850000000025,64.599999999996,31.8)); +#9760 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9761 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9762 = DEFINITIONAL_REPRESENTATION('',(#9763),#9767); +#9763 = LINE('',#9764,#9765); +#9764 = CARTESIAN_POINT('',(0.,0.)); +#9765 = VECTOR('',#9766,1.); +#9766 = DIRECTION('',(1.,2.050733463254E-31)); +#9767 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9768 = FACE_BOUND('',#9769,.T.); +#9769 = EDGE_LOOP('',(#9770,#9800,#9828,#9856)); +#9770 = ORIENTED_EDGE('',*,*,#9771,.T.); +#9771 = EDGE_CURVE('',#9772,#9774,#9776,.T.); +#9772 = VERTEX_POINT('',#9773); +#9773 = CARTESIAN_POINT('',(10.449999999975,64.599999999996,31.5)); +#9774 = VERTEX_POINT('',#9775); +#9775 = CARTESIAN_POINT('',(7.449999999975,64.599999999996,31.5)); +#9776 = SURFACE_CURVE('',#9777,(#9781,#9788),.PCURVE_S1.); +#9777 = LINE('',#9778,#9779); +#9778 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9779 = VECTOR('',#9780,1.); +#9780 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9781 = PCURVE('',#3276,#9782); +#9782 = DEFINITIONAL_REPRESENTATION('',(#9783),#9787); +#9783 = LINE('',#9784,#9785); +#9784 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#9785 = VECTOR('',#9786,1.); +#9786 = DIRECTION('',(1.,0.)); +#9787 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9788 = PCURVE('',#9789,#9794); +#9789 = PLANE('',#9790); +#9790 = AXIS2_PLACEMENT_3D('',#9791,#9792,#9793); +#9791 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9792 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#9793 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9794 = DEFINITIONAL_REPRESENTATION('',(#9795),#9799); +#9795 = LINE('',#9796,#9797); +#9796 = CARTESIAN_POINT('',(0.,0.)); +#9797 = VECTOR('',#9798,1.); +#9798 = DIRECTION('',(-1.,1.62688410619E-44)); +#9799 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9800 = ORIENTED_EDGE('',*,*,#9801,.T.); +#9801 = EDGE_CURVE('',#9774,#9802,#9804,.T.); +#9802 = VERTEX_POINT('',#9803); +#9803 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 16.949999999951)); +#9804 = SURFACE_CURVE('',#9805,(#9809,#9816),.PCURVE_S1.); +#9805 = LINE('',#9806,#9807); +#9806 = CARTESIAN_POINT('',(7.149999999975,64.599999999996,31.8)); +#9807 = VECTOR('',#9808,1.); +#9808 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9809 = PCURVE('',#3276,#9810); +#9810 = DEFINITIONAL_REPRESENTATION('',(#9811),#9815); +#9811 = LINE('',#9812,#9813); +#9812 = CARTESIAN_POINT('',(-29.84999999998,13.650000000013)); +#9813 = VECTOR('',#9814,1.); +#9814 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9815 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9816 = PCURVE('',#9817,#9822); +#9817 = PLANE('',#9818); +#9818 = AXIS2_PLACEMENT_3D('',#9819,#9820,#9821); +#9819 = CARTESIAN_POINT('',(32.449999999986,64.599999999996, + 6.499999999988)); +#9820 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9821 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9822 = DEFINITIONAL_REPRESENTATION('',(#9823),#9827); +#9823 = LINE('',#9824,#9825); +#9824 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9825 = VECTOR('',#9826,1.); +#9826 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9827 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9828 = ORIENTED_EDGE('',*,*,#9829,.T.); +#9829 = EDGE_CURVE('',#9802,#9830,#9832,.T.); +#9830 = VERTEX_POINT('',#9831); +#9831 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 19.949999999952)); +#9832 = SURFACE_CURVE('',#9833,(#9837,#9844),.PCURVE_S1.); +#9833 = LINE('',#9834,#9835); +#9834 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#9835 = VECTOR('',#9836,1.); +#9836 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9837 = PCURVE('',#3276,#9838); +#9838 = DEFINITIONAL_REPRESENTATION('',(#9839),#9843); +#9839 = LINE('',#9840,#9841); +#9840 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#9841 = VECTOR('',#9842,1.); +#9842 = DIRECTION('',(0.,1.)); +#9843 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9844 = PCURVE('',#9845,#9850); +#9845 = PLANE('',#9846); +#9846 = AXIS2_PLACEMENT_3D('',#9847,#9848,#9849); +#9847 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#9848 = DIRECTION('',(-1.,-4.440892098501E-15,6.710814671636E-29)); +#9849 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9850 = DEFINITIONAL_REPRESENTATION('',(#9851),#9855); +#9851 = LINE('',#9852,#9853); +#9852 = CARTESIAN_POINT('',(0.,0.)); +#9853 = VECTOR('',#9854,1.); +#9854 = DIRECTION('',(-1.,-3.944304526105E-31)); +#9855 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9856 = ORIENTED_EDGE('',*,*,#9857,.F.); +#9857 = EDGE_CURVE('',#9772,#9830,#9858,.T.); +#9858 = SURFACE_CURVE('',#9859,(#9863,#9870),.PCURVE_S1.); +#9859 = LINE('',#9860,#9861); +#9860 = CARTESIAN_POINT('',(10.149999999975,64.599999999996,31.8)); +#9861 = VECTOR('',#9862,1.); +#9862 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9863 = PCURVE('',#3276,#9864); +#9864 = DEFINITIONAL_REPRESENTATION('',(#9865),#9869); +#9865 = LINE('',#9866,#9867); +#9866 = CARTESIAN_POINT('',(-32.84999999998,13.650000000013)); +#9867 = VECTOR('',#9868,1.); +#9868 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9869 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9870 = PCURVE('',#9871,#9876); +#9871 = PLANE('',#9872); +#9872 = AXIS2_PLACEMENT_3D('',#9873,#9874,#9875); +#9873 = CARTESIAN_POINT('',(10.149999999975,64.599999999996,31.8)); +#9874 = DIRECTION('',(-0.707106781187,-3.226780522991E-15, + -0.707106781187)); +#9875 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9876 = DEFINITIONAL_REPRESENTATION('',(#9877),#9881); +#9877 = LINE('',#9878,#9879); +#9878 = CARTESIAN_POINT('',(0.,0.)); +#9879 = VECTOR('',#9880,1.); +#9880 = DIRECTION('',(1.,-4.361251546428E-31)); +#9881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9882 = FACE_BOUND('',#9883,.T.); +#9883 = EDGE_LOOP('',(#9884,#9914,#9942)); +#9884 = ORIENTED_EDGE('',*,*,#9885,.T.); +#9885 = EDGE_CURVE('',#9886,#9888,#9890,.T.); +#9886 = VERTEX_POINT('',#9887); +#9887 = CARTESIAN_POINT('',(19.449999999975,64.599999999996,31.5)); +#9888 = VERTEX_POINT('',#9889); +#9889 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 28.949999999951)); +#9890 = SURFACE_CURVE('',#9891,(#9895,#9902),.PCURVE_S1.); +#9891 = LINE('',#9892,#9893); +#9892 = CARTESIAN_POINT('',(19.149999999975,64.599999999996,31.8)); +#9893 = VECTOR('',#9894,1.); +#9894 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187) + ); +#9895 = PCURVE('',#3276,#9896); +#9896 = DEFINITIONAL_REPRESENTATION('',(#9897),#9901); +#9897 = LINE('',#9898,#9899); +#9898 = CARTESIAN_POINT('',(-41.84999999998,13.650000000013)); +#9899 = VECTOR('',#9900,1.); +#9900 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#9901 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9902 = PCURVE('',#9903,#9908); +#9903 = PLANE('',#9904); +#9904 = AXIS2_PLACEMENT_3D('',#9905,#9906,#9907); +#9905 = CARTESIAN_POINT('',(44.449999999986,64.599999999996, + 6.499999999988)); +#9906 = DIRECTION('',(0.707106781187,3.226780522991E-15,0.707106781187) + ); +#9907 = DIRECTION('',(-0.707106781187,-1.656092836981E-15,0.707106781187 + )); +#9908 = DEFINITIONAL_REPRESENTATION('',(#9909),#9913); +#9909 = LINE('',#9910,#9911); +#9910 = CARTESIAN_POINT('',(35.779603128055,2.601078384082E-14)); +#9911 = VECTOR('',#9912,1.); +#9912 = DIRECTION('',(-1.,-3.871099052181E-31)); +#9913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9914 = ORIENTED_EDGE('',*,*,#9915,.T.); +#9915 = EDGE_CURVE('',#9888,#9916,#9918,.T.); +#9916 = VERTEX_POINT('',#9917); +#9917 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#9918 = SURFACE_CURVE('',#9919,(#9923,#9930),.PCURVE_S1.); +#9919 = LINE('',#9920,#9921); +#9920 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#9921 = VECTOR('',#9922,1.); +#9922 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#9923 = PCURVE('',#3276,#9924); +#9924 = DEFINITIONAL_REPRESENTATION('',(#9925),#9929); +#9925 = LINE('',#9926,#9927); +#9926 = CARTESIAN_POINT('',(-44.70000000003,13.350000000013)); +#9927 = VECTOR('',#9928,1.); +#9928 = DIRECTION('',(0.,1.)); +#9929 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9930 = PCURVE('',#9931,#9936); +#9931 = PLANE('',#9932); +#9932 = AXIS2_PLACEMENT_3D('',#9933,#9934,#9935); +#9933 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#9934 = DIRECTION('',(-1.,-4.440892098501E-15,6.710814671636E-29)); +#9935 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#9936 = DEFINITIONAL_REPRESENTATION('',(#9937),#9941); +#9937 = LINE('',#9938,#9939); +#9938 = CARTESIAN_POINT('',(0.,0.)); +#9939 = VECTOR('',#9940,1.); +#9940 = DIRECTION('',(-1.,-3.944304526105E-31)); +#9941 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9942 = ORIENTED_EDGE('',*,*,#9943,.T.); +#9943 = EDGE_CURVE('',#9916,#9886,#9944,.T.); +#9944 = SURFACE_CURVE('',#9945,(#9949,#9956),.PCURVE_S1.); +#9945 = LINE('',#9946,#9947); +#9946 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9947 = VECTOR('',#9948,1.); +#9948 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#9949 = PCURVE('',#3276,#9950); +#9950 = DEFINITIONAL_REPRESENTATION('',(#9951),#9955); +#9951 = LINE('',#9952,#9953); +#9952 = CARTESIAN_POINT('',(3.29999999999,13.350000000013)); +#9953 = VECTOR('',#9954,1.); +#9954 = DIRECTION('',(1.,0.)); +#9955 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9956 = PCURVE('',#9957,#9962); +#9957 = PLANE('',#9958); +#9958 = AXIS2_PLACEMENT_3D('',#9959,#9960,#9961); +#9959 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#9960 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#9961 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#9962 = DEFINITIONAL_REPRESENTATION('',(#9963),#9967); +#9963 = LINE('',#9964,#9965); +#9964 = CARTESIAN_POINT('',(0.,0.)); +#9965 = VECTOR('',#9966,1.); +#9966 = DIRECTION('',(-1.,1.62688410619E-44)); +#9967 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9968 = ADVANCED_FACE('',(#9969),#6338,.F.); +#9969 = FACE_BOUND('',#9970,.F.); +#9970 = EDGE_LOOP('',(#9971,#9994,#10016,#10017)); +#9971 = ORIENTED_EDGE('',*,*,#9972,.T.); +#9972 = EDGE_CURVE('',#6322,#9973,#9975,.T.); +#9973 = VERTEX_POINT('',#9974); +#9974 = CARTESIAN_POINT('',(-11.25,47.850000000023,36.5)); +#9975 = SEAM_CURVE('',#9976,(#9980,#9987),.PCURVE_S1.); +#9976 = LINE('',#9977,#9978); +#9977 = CARTESIAN_POINT('',(-11.25,47.850000000023,38.5)); +#9978 = VECTOR('',#9979,1.); +#9979 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#9980 = PCURVE('',#6338,#9981); +#9981 = DEFINITIONAL_REPRESENTATION('',(#9982),#9986); +#9982 = LINE('',#9983,#9984); +#9983 = CARTESIAN_POINT('',(3.14159265359,0.)); +#9984 = VECTOR('',#9985,1.); +#9985 = DIRECTION('',(3.330669073876E-15,1.)); +#9986 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9987 = PCURVE('',#6338,#9988); +#9988 = DEFINITIONAL_REPRESENTATION('',(#9989),#9993); +#9989 = LINE('',#9990,#9991); +#9990 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#9991 = VECTOR('',#9992,1.); +#9992 = DIRECTION('',(3.330669073876E-15,1.)); +#9993 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#9994 = ORIENTED_EDGE('',*,*,#9995,.T.); +#9995 = EDGE_CURVE('',#9973,#9973,#9996,.T.); +#9996 = SURFACE_CURVE('',#9997,(#10002,#10009),.PCURVE_S1.); +#9997 = CIRCLE('',#9998,1.05); +#9998 = AXIS2_PLACEMENT_3D('',#9999,#10000,#10001); +#9999 = CARTESIAN_POINT('',(-12.3,47.850000000023,36.5)); +#10000 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#10001 = DIRECTION('',(-1.,-1.832337233097E-30,-1.018942737707E-15)); +#10002 = PCURVE('',#6338,#10003); +#10003 = DEFINITIONAL_REPRESENTATION('',(#10004),#10008); +#10004 = LINE('',#10005,#10006); +#10005 = CARTESIAN_POINT('',(6.28318530718,2.)); +#10006 = VECTOR('',#10007,1.); +#10007 = DIRECTION('',(-1.,0.)); +#10008 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10009 = PCURVE('',#2685,#10010); +#10010 = DEFINITIONAL_REPRESENTATION('',(#10011),#10015); +#10011 = CIRCLE('',#10012,1.05); +#10012 = AXIS2_PLACEMENT_2D('',#10013,#10014); +#10013 = CARTESIAN_POINT('',(-10.30000000001,47.850000000024)); +#10014 = DIRECTION('',(-1.,-1.707552736872E-30)); +#10015 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10016 = ORIENTED_EDGE('',*,*,#9972,.F.); +#10017 = ORIENTED_EDGE('',*,*,#6321,.T.); +#10018 = ADVANCED_FACE('',(#10019),#6370,.F.); +#10019 = FACE_BOUND('',#10020,.T.); +#10020 = EDGE_LOOP('',(#10021,#10046,#10067,#10068)); +#10021 = ORIENTED_EDGE('',*,*,#10022,.F.); +#10022 = EDGE_CURVE('',#10023,#10025,#10027,.T.); +#10023 = VERTEX_POINT('',#10024); +#10024 = CARTESIAN_POINT('',(15.79999999998,43.499999999973,36.5)); +#10025 = VERTEX_POINT('',#10026); +#10026 = CARTESIAN_POINT('',(15.800000000045,52.19999999996,36.5)); +#10027 = SURFACE_CURVE('',#10028,(#10032,#10039),.PCURVE_S1.); +#10028 = LINE('',#10029,#10030); +#10029 = CARTESIAN_POINT('',(15.799999999851,26.099999999913,36.5)); +#10030 = VECTOR('',#10031,1.); +#10031 = DIRECTION('',(7.456615146551E-12,1.,-1.798273018963E-15)); +#10032 = PCURVE('',#6370,#10033); +#10033 = DEFINITIONAL_REPRESENTATION('',(#10034),#10038); +#10034 = LINE('',#10035,#10036); +#10035 = CARTESIAN_POINT('',(26.100000000047,2.)); +#10036 = VECTOR('',#10037,1.); +#10037 = DIRECTION('',(-1.,-3.048813858958E-16)); +#10038 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10039 = PCURVE('',#2685,#10040); +#10040 = DEFINITIONAL_REPRESENTATION('',(#10041),#10045); +#10041 = LINE('',#10042,#10043); +#10042 = CARTESIAN_POINT('',(17.799999999841,26.099999999914)); +#10043 = VECTOR('',#10044,1.); +#10044 = DIRECTION('',(7.456615146551E-12,1.)); +#10045 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10046 = ORIENTED_EDGE('',*,*,#10047,.F.); +#10047 = EDGE_CURVE('',#6355,#10023,#10048,.T.); +#10048 = SURFACE_CURVE('',#10049,(#10053,#10060),.PCURVE_S1.); +#10049 = LINE('',#10050,#10051); +#10050 = CARTESIAN_POINT('',(15.79999999998,43.499999999973,38.5)); +#10051 = VECTOR('',#10052,1.); +#10052 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10053 = PCURVE('',#6370,#10054); +#10054 = DEFINITIONAL_REPRESENTATION('',(#10055),#10059); +#10055 = LINE('',#10056,#10057); +#10056 = CARTESIAN_POINT('',(8.699999999987,1.829744332225E-14)); +#10057 = VECTOR('',#10058,1.); +#10058 = DIRECTION('',(2.894979576369E-17,1.)); +#10059 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10060 = PCURVE('',#6398,#10061); +#10061 = DEFINITIONAL_REPRESENTATION('',(#10062),#10066); +#10062 = LINE('',#10063,#10064); +#10063 = CARTESIAN_POINT('',(0.,0.)); +#10064 = VECTOR('',#10065,1.); +#10065 = DIRECTION('',(-1.458177856386E-27,1.)); +#10066 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10067 = ORIENTED_EDGE('',*,*,#6352,.F.); +#10068 = ORIENTED_EDGE('',*,*,#10069,.T.); +#10069 = EDGE_CURVE('',#6353,#10025,#10070,.T.); +#10070 = SURFACE_CURVE('',#10071,(#10075,#10082),.PCURVE_S1.); +#10071 = LINE('',#10072,#10073); +#10072 = CARTESIAN_POINT('',(15.800000000045,52.19999999996,38.5)); +#10073 = VECTOR('',#10074,1.); +#10074 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10075 = PCURVE('',#6370,#10076); +#10076 = DEFINITIONAL_REPRESENTATION('',(#10077),#10081); +#10077 = LINE('',#10078,#10079); +#10078 = CARTESIAN_POINT('',(0.,0.)); +#10079 = VECTOR('',#10080,1.); +#10080 = DIRECTION('',(2.894979576369E-17,1.)); +#10081 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10082 = PCURVE('',#6452,#10083); +#10083 = DEFINITIONAL_REPRESENTATION('',(#10084),#10088); +#10084 = LINE('',#10085,#10086); +#10085 = CARTESIAN_POINT('',(25.600000000045,9.940748078378E-26)); +#10086 = VECTOR('',#10087,1.); +#10087 = DIRECTION('',(1.495792554248E-27,1.)); +#10088 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10089 = ADVANCED_FACE('',(#10090),#6452,.F.); +#10090 = FACE_BOUND('',#10091,.T.); +#10091 = EDGE_LOOP('',(#10092,#10115,#10116,#10117)); +#10092 = ORIENTED_EDGE('',*,*,#10093,.F.); +#10093 = EDGE_CURVE('',#10025,#10094,#10096,.T.); +#10094 = VERTEX_POINT('',#10095); +#10095 = CARTESIAN_POINT('',(-9.8,52.200000000026,36.5)); +#10096 = SURFACE_CURVE('',#10097,(#10101,#10108),.PCURVE_S1.); +#10097 = LINE('',#10098,#10099); +#10098 = CARTESIAN_POINT('',(-5.899999999928,52.200000000016,36.5)); +#10099 = VECTOR('',#10100,1.); +#10100 = DIRECTION('',(-1.,2.584737979201E-12,-1.018942737711E-15)); +#10101 = PCURVE('',#6452,#10102); +#10102 = DEFINITIONAL_REPRESENTATION('',(#10103),#10107); +#10103 = LINE('',#10104,#10105); +#10104 = CARTESIAN_POINT('',(3.900000000072,2.)); +#10105 = VECTOR('',#10106,1.); +#10106 = DIRECTION('',(-1.,1.018942737707E-15)); +#10107 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10108 = PCURVE('',#2685,#10109); +#10109 = DEFINITIONAL_REPRESENTATION('',(#10110),#10114); +#10110 = LINE('',#10111,#10112); +#10111 = CARTESIAN_POINT('',(-3.899999999937,52.200000000018)); +#10112 = VECTOR('',#10113,1.); +#10113 = DIRECTION('',(-1.,2.584737979201E-12)); +#10114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10115 = ORIENTED_EDGE('',*,*,#10069,.F.); +#10116 = ORIENTED_EDGE('',*,*,#6438,.F.); +#10117 = ORIENTED_EDGE('',*,*,#10118,.T.); +#10118 = EDGE_CURVE('',#6411,#10094,#10119,.T.); +#10119 = SURFACE_CURVE('',#10120,(#10124,#10131),.PCURVE_S1.); +#10120 = LINE('',#10121,#10122); +#10121 = CARTESIAN_POINT('',(-9.8,52.200000000026,38.5)); +#10122 = VECTOR('',#10123,1.); +#10123 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10124 = PCURVE('',#6452,#10125); +#10125 = DEFINITIONAL_REPRESENTATION('',(#10126),#10130); +#10126 = LINE('',#10127,#10128); +#10127 = CARTESIAN_POINT('',(0.,0.)); +#10128 = VECTOR('',#10129,1.); +#10129 = DIRECTION('',(1.495792554248E-27,1.)); +#10130 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10131 = PCURVE('',#6426,#10132); +#10132 = DEFINITIONAL_REPRESENTATION('',(#10133),#10137); +#10133 = LINE('',#10134,#10135); +#10134 = CARTESIAN_POINT('',(8.70000000002,-1.829744332231E-14)); +#10135 = VECTOR('',#10136,1.); +#10136 = DIRECTION('',(-2.894979576369E-17,1.)); +#10137 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10138 = ADVANCED_FACE('',(#10139),#6426,.F.); +#10139 = FACE_BOUND('',#10140,.T.); +#10140 = EDGE_LOOP('',(#10141,#10164,#10165,#10166)); +#10141 = ORIENTED_EDGE('',*,*,#10142,.F.); +#10142 = EDGE_CURVE('',#10094,#10143,#10145,.T.); +#10143 = VERTEX_POINT('',#10144); +#10144 = CARTESIAN_POINT('',(-9.8,43.500000000006,36.5)); +#10145 = SURFACE_CURVE('',#10146,(#10150,#10157),.PCURVE_S1.); +#10146 = LINE('',#10147,#10148); +#10147 = CARTESIAN_POINT('',(-9.8,21.750000000002,36.5)); +#10148 = VECTOR('',#10149,1.); +#10149 = DIRECTION('',(-2.04178947057E-15,-1.,1.798273018971E-15)); +#10150 = PCURVE('',#6426,#10151); +#10151 = DEFINITIONAL_REPRESENTATION('',(#10152),#10156); +#10152 = LINE('',#10153,#10154); +#10153 = CARTESIAN_POINT('',(-21.75,2.)); +#10154 = VECTOR('',#10155,1.); +#10155 = DIRECTION('',(-1.,3.048813858882E-16)); +#10156 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10157 = PCURVE('',#2685,#10158); +#10158 = DEFINITIONAL_REPRESENTATION('',(#10159),#10163); +#10159 = LINE('',#10160,#10161); +#10160 = CARTESIAN_POINT('',(-7.80000000001,21.750000000004)); +#10161 = VECTOR('',#10162,1.); +#10162 = DIRECTION('',(-2.04178947057E-15,-1.)); +#10163 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10164 = ORIENTED_EDGE('',*,*,#10118,.F.); +#10165 = ORIENTED_EDGE('',*,*,#6410,.F.); +#10166 = ORIENTED_EDGE('',*,*,#10167,.T.); +#10167 = EDGE_CURVE('',#6383,#10143,#10168,.T.); +#10168 = SURFACE_CURVE('',#10169,(#10173,#10180),.PCURVE_S1.); +#10169 = LINE('',#10170,#10171); +#10170 = CARTESIAN_POINT('',(-9.8,43.500000000006,38.5)); +#10171 = VECTOR('',#10172,1.); +#10172 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10173 = PCURVE('',#6426,#10174); +#10174 = DEFINITIONAL_REPRESENTATION('',(#10175),#10179); +#10175 = LINE('',#10176,#10177); +#10176 = CARTESIAN_POINT('',(0.,0.)); +#10177 = VECTOR('',#10178,1.); +#10178 = DIRECTION('',(-2.894979576369E-17,1.)); +#10179 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10180 = PCURVE('',#6398,#10181); +#10181 = DEFINITIONAL_REPRESENTATION('',(#10182),#10186); +#10182 = LINE('',#10183,#10184); +#10183 = CARTESIAN_POINT('',(25.59999999998,-2.944040412954E-26)); +#10184 = VECTOR('',#10185,1.); +#10185 = DIRECTION('',(-1.458177856386E-27,1.)); +#10186 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10187 = ADVANCED_FACE('',(#10188),#6398,.F.); +#10188 = FACE_BOUND('',#10189,.T.); +#10189 = EDGE_LOOP('',(#10190,#10211,#10212,#10213)); +#10190 = ORIENTED_EDGE('',*,*,#10191,.F.); +#10191 = EDGE_CURVE('',#10143,#10023,#10192,.T.); +#10192 = SURFACE_CURVE('',#10193,(#10197,#10204),.PCURVE_S1.); +#10193 = LINE('',#10194,#10195); +#10194 = CARTESIAN_POINT('',(6.900000000023,43.499999999985,36.5)); +#10195 = VECTOR('',#10196,1.); +#10196 = DIRECTION('',(1.,-1.2854300957E-12,1.018942737709E-15)); +#10197 = PCURVE('',#6398,#10198); +#10198 = DEFINITIONAL_REPRESENTATION('',(#10199),#10203); +#10199 = LINE('',#10200,#10201); +#10200 = CARTESIAN_POINT('',(8.899999999957,2.)); +#10201 = VECTOR('',#10202,1.); +#10202 = DIRECTION('',(-1.,-1.018942737708E-15)); +#10203 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10204 = PCURVE('',#2685,#10205); +#10205 = DEFINITIONAL_REPRESENTATION('',(#10206),#10210); +#10206 = LINE('',#10207,#10208); +#10207 = CARTESIAN_POINT('',(8.900000000013,43.499999999986)); +#10208 = VECTOR('',#10209,1.); +#10209 = DIRECTION('',(1.,-1.2854300957E-12)); +#10210 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10211 = ORIENTED_EDGE('',*,*,#10167,.F.); +#10212 = ORIENTED_EDGE('',*,*,#6382,.F.); +#10213 = ORIENTED_EDGE('',*,*,#10047,.T.); +#10214 = ADVANCED_FACE('',(#10215),#6484,.F.); +#10215 = FACE_BOUND('',#10216,.T.); +#10216 = EDGE_LOOP('',(#10217,#10242,#10263,#10264)); +#10217 = ORIENTED_EDGE('',*,*,#10218,.F.); +#10218 = EDGE_CURVE('',#10219,#10221,#10223,.T.); +#10219 = VERTEX_POINT('',#10220); +#10220 = CARTESIAN_POINT('',(15.800000000003,38.600000000008,36.5)); +#10221 = VERTEX_POINT('',#10222); +#10222 = CARTESIAN_POINT('',(15.799999999991,41.899999999966,36.5)); +#10223 = SURFACE_CURVE('',#10224,(#10228,#10235),.PCURVE_S1.); +#10224 = LINE('',#10225,#10226); +#10225 = CARTESIAN_POINT('',(15.800000000067,20.950000000015,36.5)); +#10226 = VECTOR('',#10227,1.); +#10227 = DIRECTION('',(-3.641531520817E-12,1.,-1.798273018974E-15)); +#10228 = PCURVE('',#6484,#10229); +#10229 = DEFINITIONAL_REPRESENTATION('',(#10230),#10234); +#10230 = LINE('',#10231,#10232); +#10231 = CARTESIAN_POINT('',(20.949999999951,2.)); +#10232 = VECTOR('',#10233,1.); +#10233 = DIRECTION('',(-1.,-3.048813858844E-16)); +#10234 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10235 = PCURVE('',#2685,#10236); +#10236 = DEFINITIONAL_REPRESENTATION('',(#10237),#10241); +#10237 = LINE('',#10238,#10239); +#10238 = CARTESIAN_POINT('',(17.800000000058,20.950000000016)); +#10239 = VECTOR('',#10240,1.); +#10240 = DIRECTION('',(-3.641531520817E-12,1.)); +#10241 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10242 = ORIENTED_EDGE('',*,*,#10243,.F.); +#10243 = EDGE_CURVE('',#6469,#10219,#10244,.T.); +#10244 = SURFACE_CURVE('',#10245,(#10249,#10256),.PCURVE_S1.); +#10245 = LINE('',#10246,#10247); +#10246 = CARTESIAN_POINT('',(15.800000000003,38.600000000008,38.5)); +#10247 = VECTOR('',#10248,1.); +#10248 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10249 = PCURVE('',#6484,#10250); +#10250 = DEFINITIONAL_REPRESENTATION('',(#10251),#10255); +#10251 = LINE('',#10252,#10253); +#10252 = CARTESIAN_POINT('',(3.299999999958,6.940409535946E-15)); +#10253 = VECTOR('',#10254,1.); +#10254 = DIRECTION('',(2.894979576369E-17,1.)); +#10255 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10256 = PCURVE('',#6512,#10257); +#10257 = DEFINITIONAL_REPRESENTATION('',(#10258),#10262); +#10258 = LINE('',#10259,#10260); +#10259 = CARTESIAN_POINT('',(0.,0.)); +#10260 = VECTOR('',#10261,1.); +#10261 = DIRECTION('',(-1.411322698703E-27,1.)); +#10262 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10263 = ORIENTED_EDGE('',*,*,#6466,.F.); +#10264 = ORIENTED_EDGE('',*,*,#10265,.T.); +#10265 = EDGE_CURVE('',#6467,#10221,#10266,.T.); +#10266 = SURFACE_CURVE('',#10267,(#10271,#10278),.PCURVE_S1.); +#10267 = LINE('',#10268,#10269); +#10268 = CARTESIAN_POINT('',(15.799999999991,41.899999999966,38.5)); +#10269 = VECTOR('',#10270,1.); +#10270 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10271 = PCURVE('',#6484,#10272); +#10272 = DEFINITIONAL_REPRESENTATION('',(#10273),#10277); +#10273 = LINE('',#10274,#10275); +#10274 = CARTESIAN_POINT('',(0.,0.)); +#10275 = VECTOR('',#10276,1.); +#10276 = DIRECTION('',(2.894979576369E-17,1.)); +#10277 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10278 = PCURVE('',#6566,#10279); +#10279 = DEFINITIONAL_REPRESENTATION('',(#10280),#10284); +#10280 = LINE('',#10281,#10282); +#10281 = CARTESIAN_POINT('',(25.59999999999,2.960473462366E-26)); +#10282 = VECTOR('',#10283,1.); +#10283 = DIRECTION('',(1.458268252189E-27,1.)); +#10284 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10285 = ADVANCED_FACE('',(#10286),#6566,.F.); +#10286 = FACE_BOUND('',#10287,.T.); +#10287 = EDGE_LOOP('',(#10288,#10311,#10312,#10313)); +#10288 = ORIENTED_EDGE('',*,*,#10289,.F.); +#10289 = EDGE_CURVE('',#10221,#10290,#10292,.T.); +#10290 = VERTEX_POINT('',#10291); +#10291 = CARTESIAN_POINT('',(-9.799999999999,41.899999999999,36.5)); +#10292 = SURFACE_CURVE('',#10293,(#10297,#10304),.PCURVE_S1.); +#10293 = LINE('',#10294,#10295); +#10294 = CARTESIAN_POINT('',(-5.899999999968,41.899999999994,36.5)); +#10295 = VECTOR('',#10296,1.); +#10296 = DIRECTION('',(-1.,1.288552597956E-12,-1.018942737709E-15)); +#10297 = PCURVE('',#6566,#10298); +#10298 = DEFINITIONAL_REPRESENTATION('',(#10299),#10303); +#10299 = LINE('',#10300,#10301); +#10300 = CARTESIAN_POINT('',(3.900000000031,2.)); +#10301 = VECTOR('',#10302,1.); +#10302 = DIRECTION('',(-1.,1.018942737708E-15)); +#10303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10304 = PCURVE('',#2685,#10305); +#10305 = DEFINITIONAL_REPRESENTATION('',(#10306),#10310); +#10306 = LINE('',#10307,#10308); +#10307 = CARTESIAN_POINT('',(-3.899999999977,41.899999999996)); +#10308 = VECTOR('',#10309,1.); +#10309 = DIRECTION('',(-1.,1.288552597956E-12)); +#10310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10311 = ORIENTED_EDGE('',*,*,#10265,.F.); +#10312 = ORIENTED_EDGE('',*,*,#6552,.F.); +#10313 = ORIENTED_EDGE('',*,*,#10314,.T.); +#10314 = EDGE_CURVE('',#6525,#10290,#10315,.T.); +#10315 = SURFACE_CURVE('',#10316,(#10320,#10327),.PCURVE_S1.); +#10316 = LINE('',#10317,#10318); +#10317 = CARTESIAN_POINT('',(-9.799999999999,41.899999999999,38.5)); +#10318 = VECTOR('',#10319,1.); +#10319 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10320 = PCURVE('',#6566,#10321); +#10321 = DEFINITIONAL_REPRESENTATION('',(#10322),#10326); +#10322 = LINE('',#10323,#10324); +#10323 = CARTESIAN_POINT('',(0.,0.)); +#10324 = VECTOR('',#10325,1.); +#10325 = DIRECTION('',(1.458268252189E-27,1.)); +#10326 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10327 = PCURVE('',#6540,#10328); +#10328 = DEFINITIONAL_REPRESENTATION('',(#10329),#10333); +#10329 = LINE('',#10330,#10331); +#10330 = CARTESIAN_POINT('',(3.299999999999,-6.940409536033E-15)); +#10331 = VECTOR('',#10332,1.); +#10332 = DIRECTION('',(-2.894979576369E-17,1.)); +#10333 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10334 = ADVANCED_FACE('',(#10335),#6540,.F.); +#10335 = FACE_BOUND('',#10336,.T.); +#10336 = EDGE_LOOP('',(#10337,#10360,#10361,#10362)); +#10337 = ORIENTED_EDGE('',*,*,#10338,.F.); +#10338 = EDGE_CURVE('',#10290,#10339,#10341,.T.); +#10339 = VERTEX_POINT('',#10340); +#10340 = CARTESIAN_POINT('',(-9.799999999997,38.6,36.5)); +#10341 = SURFACE_CURVE('',#10342,(#10346,#10353),.PCURVE_S1.); +#10342 = LINE('',#10343,#10344); +#10343 = CARTESIAN_POINT('',(-9.799999999983,19.299999999996,36.5)); +#10344 = VECTOR('',#10345,1.); +#10345 = DIRECTION('',(6.917025874635E-13,-1.,1.798273018971E-15)); +#10346 = PCURVE('',#6540,#10347); +#10347 = DEFINITIONAL_REPRESENTATION('',(#10348),#10352); +#10348 = LINE('',#10349,#10350); +#10349 = CARTESIAN_POINT('',(-19.3,2.)); +#10350 = VECTOR('',#10351,1.); +#10351 = DIRECTION('',(-1.,3.048813858874E-16)); +#10352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10353 = PCURVE('',#2685,#10354); +#10354 = DEFINITIONAL_REPRESENTATION('',(#10355),#10359); +#10355 = LINE('',#10356,#10357); +#10356 = CARTESIAN_POINT('',(-7.799999999993,19.299999999998)); +#10357 = VECTOR('',#10358,1.); +#10358 = DIRECTION('',(6.917025874635E-13,-1.)); +#10359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10360 = ORIENTED_EDGE('',*,*,#10314,.F.); +#10361 = ORIENTED_EDGE('',*,*,#6524,.F.); +#10362 = ORIENTED_EDGE('',*,*,#10363,.T.); +#10363 = EDGE_CURVE('',#6497,#10339,#10364,.T.); +#10364 = SURFACE_CURVE('',#10365,(#10369,#10376),.PCURVE_S1.); +#10365 = LINE('',#10366,#10367); +#10366 = CARTESIAN_POINT('',(-9.799999999997,38.6,38.5)); +#10367 = VECTOR('',#10368,1.); +#10368 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10369 = PCURVE('',#6540,#10370); +#10370 = DEFINITIONAL_REPRESENTATION('',(#10371),#10375); +#10371 = LINE('',#10372,#10373); +#10372 = CARTESIAN_POINT('',(0.,0.)); +#10373 = VECTOR('',#10374,1.); +#10374 = DIRECTION('',(-2.894979576369E-17,1.)); +#10375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10376 = PCURVE('',#6512,#10377); +#10377 = DEFINITIONAL_REPRESENTATION('',(#10378),#10382); +#10378 = LINE('',#10379,#10380); +#10379 = CARTESIAN_POINT('',(25.6,5.769690548569E-26)); +#10380 = VECTOR('',#10381,1.); +#10381 = DIRECTION('',(-1.411322698703E-27,1.)); +#10382 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10383 = ADVANCED_FACE('',(#10384),#6512,.F.); +#10384 = FACE_BOUND('',#10385,.T.); +#10385 = EDGE_LOOP('',(#10386,#10407,#10408,#10409)); +#10386 = ORIENTED_EDGE('',*,*,#10387,.F.); +#10387 = EDGE_CURVE('',#10339,#10219,#10388,.T.); +#10388 = SURFACE_CURVE('',#10389,(#10393,#10400),.PCURVE_S1.); +#10389 = LINE('',#10390,#10391); +#10390 = CARTESIAN_POINT('',(6.9,38.600000000005,36.5)); +#10391 = VECTOR('',#10392,1.); +#10392 = DIRECTION('',(1.,3.330669073875E-13,1.018942737706E-15)); +#10393 = PCURVE('',#6512,#10394); +#10394 = DEFINITIONAL_REPRESENTATION('',(#10395),#10399); +#10395 = LINE('',#10396,#10397); +#10396 = CARTESIAN_POINT('',(8.900000000003,2.)); +#10397 = VECTOR('',#10398,1.); +#10398 = DIRECTION('',(-1.,-1.018942737708E-15)); +#10399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10400 = PCURVE('',#2685,#10401); +#10401 = DEFINITIONAL_REPRESENTATION('',(#10402),#10406); +#10402 = LINE('',#10403,#10404); +#10403 = CARTESIAN_POINT('',(8.89999999999,38.600000000007)); +#10404 = VECTOR('',#10405,1.); +#10405 = DIRECTION('',(1.,3.330669073875E-13)); +#10406 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10407 = ORIENTED_EDGE('',*,*,#10363,.F.); +#10408 = ORIENTED_EDGE('',*,*,#6496,.F.); +#10409 = ORIENTED_EDGE('',*,*,#10243,.T.); +#10410 = ADVANCED_FACE('',(#10411),#6597,.F.); +#10411 = FACE_BOUND('',#10412,.F.); +#10412 = EDGE_LOOP('',(#10413,#10436,#10458,#10459)); +#10413 = ORIENTED_EDGE('',*,*,#10414,.T.); +#10414 = EDGE_CURVE('',#6581,#10415,#10417,.T.); +#10415 = VERTEX_POINT('',#10416); +#10416 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,36.5)); +#10417 = SEAM_CURVE('',#10418,(#10422,#10429),.PCURVE_S1.); +#10418 = LINE('',#10419,#10420); +#10419 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,38.5)); +#10420 = VECTOR('',#10421,1.); +#10421 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10422 = PCURVE('',#6597,#10423); +#10423 = DEFINITIONAL_REPRESENTATION('',(#10424),#10428); +#10424 = LINE('',#10425,#10426); +#10425 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10426 = VECTOR('',#10427,1.); +#10427 = DIRECTION('',(3.330669073876E-15,1.)); +#10428 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10429 = PCURVE('',#6597,#10430); +#10430 = DEFINITIONAL_REPRESENTATION('',(#10431),#10435); +#10431 = LINE('',#10432,#10433); +#10432 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#10433 = VECTOR('',#10434,1.); +#10434 = DIRECTION('',(3.330669073876E-15,1.)); +#10435 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10436 = ORIENTED_EDGE('',*,*,#10437,.T.); +#10437 = EDGE_CURVE('',#10415,#10415,#10438,.T.); +#10438 = SURFACE_CURVE('',#10439,(#10444,#10451),.PCURVE_S1.); +#10439 = CIRCLE('',#10440,1.05); +#10440 = AXIS2_PLACEMENT_3D('',#10441,#10442,#10443); +#10441 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,36.5)); +#10442 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#10443 = DIRECTION('',(-1.,-1.832337233097E-30,-1.018942737707E-15)); +#10444 = PCURVE('',#6597,#10445); +#10445 = DEFINITIONAL_REPRESENTATION('',(#10446),#10450); +#10446 = LINE('',#10447,#10448); +#10447 = CARTESIAN_POINT('',(6.28318530718,2.)); +#10448 = VECTOR('',#10449,1.); +#10449 = DIRECTION('',(-1.,0.)); +#10450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10451 = PCURVE('',#2685,#10452); +#10452 = DEFINITIONAL_REPRESENTATION('',(#10453),#10457); +#10453 = CIRCLE('',#10454,1.05); +#10454 = AXIS2_PLACEMENT_2D('',#10455,#10456); +#10455 = CARTESIAN_POINT('',(20.300000000018,47.84999999997)); +#10456 = DIRECTION('',(-1.,-1.707552736872E-30)); +#10457 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10458 = ORIENTED_EDGE('',*,*,#10414,.F.); +#10459 = ORIENTED_EDGE('',*,*,#6580,.T.); +#10460 = ADVANCED_FACE('',(#10461),#6628,.F.); +#10461 = FACE_BOUND('',#10462,.F.); +#10462 = EDGE_LOOP('',(#10463,#10486,#10508,#10509)); +#10463 = ORIENTED_EDGE('',*,*,#10464,.T.); +#10464 = EDGE_CURVE('',#6612,#10465,#10467,.T.); +#10465 = VERTEX_POINT('',#10466); +#10466 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,36.5)); +#10467 = SEAM_CURVE('',#10468,(#10472,#10479),.PCURVE_S1.); +#10468 = LINE('',#10469,#10470); +#10469 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,38.5)); +#10470 = VECTOR('',#10471,1.); +#10471 = DIRECTION('',(-6.616465975138E-29,-2.093457286763E-15,-1.)); +#10472 = PCURVE('',#6628,#10473); +#10473 = DEFINITIONAL_REPRESENTATION('',(#10474),#10478); +#10474 = LINE('',#10475,#10476); +#10475 = CARTESIAN_POINT('',(9.424777960769,0.)); +#10476 = VECTOR('',#10477,1.); +#10477 = DIRECTION('',(0.,1.)); +#10478 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10479 = PCURVE('',#6628,#10480); +#10480 = DEFINITIONAL_REPRESENTATION('',(#10481),#10485); +#10481 = LINE('',#10482,#10483); +#10482 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10483 = VECTOR('',#10484,1.); +#10484 = DIRECTION('',(0.,1.)); +#10485 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10486 = ORIENTED_EDGE('',*,*,#10487,.T.); +#10487 = EDGE_CURVE('',#10465,#10465,#10488,.T.); +#10488 = SURFACE_CURVE('',#10489,(#10494,#10501),.PCURVE_S1.); +#10489 = CIRCLE('',#10490,1.05); +#10490 = AXIS2_PLACEMENT_3D('',#10491,#10492,#10493); +#10491 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,36.5)); +#10492 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#10493 = DIRECTION('',(-1.,-1.832337233097E-30,-1.018942737707E-15)); +#10494 = PCURVE('',#6628,#10495); +#10495 = DEFINITIONAL_REPRESENTATION('',(#10496),#10500); +#10496 = LINE('',#10497,#10498); +#10497 = CARTESIAN_POINT('',(12.566370614359,2.)); +#10498 = VECTOR('',#10499,1.); +#10499 = DIRECTION('',(-1.,0.)); +#10500 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10501 = PCURVE('',#2685,#10502); +#10502 = DEFINITIONAL_REPRESENTATION('',(#10503),#10507); +#10503 = CIRCLE('',#10504,1.05); +#10504 = AXIS2_PLACEMENT_2D('',#10505,#10506); +#10505 = CARTESIAN_POINT('',(-15.20444504222,-33.23836007982)); +#10506 = DIRECTION('',(-1.,-1.707552736872E-30)); +#10507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10508 = ORIENTED_EDGE('',*,*,#10464,.F.); +#10509 = ORIENTED_EDGE('',*,*,#6611,.T.); +#10510 = ADVANCED_FACE('',(#10511),#6660,.F.); +#10511 = FACE_BOUND('',#10512,.T.); +#10512 = EDGE_LOOP('',(#10513,#10538,#10559,#10560)); +#10513 = ORIENTED_EDGE('',*,*,#10514,.F.); +#10514 = EDGE_CURVE('',#10515,#10517,#10519,.T.); +#10515 = VERTEX_POINT('',#10516); +#10516 = CARTESIAN_POINT('',(15.800000000046,53.79999999996,36.5)); +#10517 = VERTEX_POINT('',#10518); +#10518 = CARTESIAN_POINT('',(15.800000000051,57.099999999995,36.5)); +#10519 = SURFACE_CURVE('',#10520,(#10524,#10531),.PCURVE_S1.); +#10520 = LINE('',#10521,#10522); +#10521 = CARTESIAN_POINT('',(15.800000000007,28.549999999983,36.5)); +#10522 = VECTOR('',#10523,1.); +#10523 = DIRECTION('',(1.526052012014E-12,1.,-1.798273018969E-15)); +#10524 = PCURVE('',#6660,#10525); +#10525 = DEFINITIONAL_REPRESENTATION('',(#10526),#10530); +#10526 = LINE('',#10527,#10528); +#10527 = CARTESIAN_POINT('',(28.550000000012,2.)); +#10528 = VECTOR('',#10529,1.); +#10529 = DIRECTION('',(-1.,-3.048813858897E-16)); +#10530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10531 = PCURVE('',#2685,#10532); +#10532 = DEFINITIONAL_REPRESENTATION('',(#10533),#10537); +#10533 = LINE('',#10534,#10535); +#10534 = CARTESIAN_POINT('',(17.799999999998,28.549999999985)); +#10535 = VECTOR('',#10536,1.); +#10536 = DIRECTION('',(1.526052012014E-12,1.)); +#10537 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10538 = ORIENTED_EDGE('',*,*,#10539,.F.); +#10539 = EDGE_CURVE('',#6645,#10515,#10540,.T.); +#10540 = SURFACE_CURVE('',#10541,(#10545,#10552),.PCURVE_S1.); +#10541 = LINE('',#10542,#10543); +#10542 = CARTESIAN_POINT('',(15.800000000046,53.79999999996,38.5)); +#10543 = VECTOR('',#10544,1.); +#10544 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10545 = PCURVE('',#6660,#10546); +#10546 = DEFINITIONAL_REPRESENTATION('',(#10547),#10551); +#10547 = LINE('',#10548,#10549); +#10548 = CARTESIAN_POINT('',(3.300000000035,6.940409536109E-15)); +#10549 = VECTOR('',#10550,1.); +#10550 = DIRECTION('',(2.894979576369E-17,1.)); +#10551 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10552 = PCURVE('',#6688,#10553); +#10553 = DEFINITIONAL_REPRESENTATION('',(#10554),#10558); +#10554 = LINE('',#10555,#10556); +#10555 = CARTESIAN_POINT('',(0.,0.)); +#10556 = VECTOR('',#10557,1.); +#10557 = DIRECTION('',(-1.450192893823E-27,1.)); +#10558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10559 = ORIENTED_EDGE('',*,*,#6642,.F.); +#10560 = ORIENTED_EDGE('',*,*,#10561,.T.); +#10561 = EDGE_CURVE('',#6643,#10517,#10562,.T.); +#10562 = SURFACE_CURVE('',#10563,(#10567,#10574),.PCURVE_S1.); +#10563 = LINE('',#10564,#10565); +#10564 = CARTESIAN_POINT('',(15.800000000051,57.099999999995,38.5)); +#10565 = VECTOR('',#10566,1.); +#10566 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10567 = PCURVE('',#6660,#10568); +#10568 = DEFINITIONAL_REPRESENTATION('',(#10569),#10573); +#10569 = LINE('',#10570,#10571); +#10570 = CARTESIAN_POINT('',(0.,0.)); +#10571 = VECTOR('',#10572,1.); +#10572 = DIRECTION('',(2.894979576369E-17,1.)); +#10573 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10574 = PCURVE('',#6742,#10575); +#10575 = DEFINITIONAL_REPRESENTATION('',(#10576),#10580); +#10576 = LINE('',#10577,#10578); +#10577 = CARTESIAN_POINT('',(25.600000000051,-6.05511219321E-26)); +#10578 = VECTOR('',#10579,1.); +#10579 = DIRECTION('',(1.409785970058E-27,1.)); +#10580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10581 = ADVANCED_FACE('',(#10582),#6742,.F.); +#10582 = FACE_BOUND('',#10583,.T.); +#10583 = EDGE_LOOP('',(#10584,#10607,#10608,#10609)); +#10584 = ORIENTED_EDGE('',*,*,#10585,.F.); +#10585 = EDGE_CURVE('',#10517,#10586,#10588,.T.); +#10586 = VERTEX_POINT('',#10587); +#10587 = CARTESIAN_POINT('',(-9.8,57.099999999985,36.5)); +#10588 = SURFACE_CURVE('',#10589,(#10593,#10600),.PCURVE_S1.); +#10589 = LINE('',#10590,#10591); +#10590 = CARTESIAN_POINT('',(-5.900000000006,57.099999999987,36.5)); +#10591 = VECTOR('',#10592,1.); +#10592 = DIRECTION('',(-1.,-3.861494457517E-13,-1.018942737706E-15)); +#10593 = PCURVE('',#6742,#10594); +#10594 = DEFINITIONAL_REPRESENTATION('',(#10595),#10599); +#10595 = LINE('',#10596,#10597); +#10596 = CARTESIAN_POINT('',(3.899999999994,2.)); +#10597 = VECTOR('',#10598,1.); +#10598 = DIRECTION('',(-1.,1.018942737708E-15)); +#10599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10600 = PCURVE('',#2685,#10601); +#10601 = DEFINITIONAL_REPRESENTATION('',(#10602),#10606); +#10602 = LINE('',#10603,#10604); +#10603 = CARTESIAN_POINT('',(-3.900000000016,57.099999999988)); +#10604 = VECTOR('',#10605,1.); +#10605 = DIRECTION('',(-1.,-3.861494457517E-13)); +#10606 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10607 = ORIENTED_EDGE('',*,*,#10561,.F.); +#10608 = ORIENTED_EDGE('',*,*,#6728,.F.); +#10609 = ORIENTED_EDGE('',*,*,#10610,.T.); +#10610 = EDGE_CURVE('',#6701,#10586,#10611,.T.); +#10611 = SURFACE_CURVE('',#10612,(#10616,#10623),.PCURVE_S1.); +#10612 = LINE('',#10613,#10614); +#10613 = CARTESIAN_POINT('',(-9.8,57.099999999985,38.5)); +#10614 = VECTOR('',#10615,1.); +#10615 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10616 = PCURVE('',#6742,#10617); +#10617 = DEFINITIONAL_REPRESENTATION('',(#10618),#10622); +#10618 = LINE('',#10619,#10620); +#10619 = CARTESIAN_POINT('',(0.,0.)); +#10620 = VECTOR('',#10621,1.); +#10621 = DIRECTION('',(1.409785970058E-27,1.)); +#10622 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10623 = PCURVE('',#6716,#10624); +#10624 = DEFINITIONAL_REPRESENTATION('',(#10625),#10629); +#10625 = LINE('',#10626,#10627); +#10626 = CARTESIAN_POINT('',(3.3,-6.940409536034E-15)); +#10627 = VECTOR('',#10628,1.); +#10628 = DIRECTION('',(-2.894979576369E-17,1.)); +#10629 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10630 = ADVANCED_FACE('',(#10631),#6716,.F.); +#10631 = FACE_BOUND('',#10632,.T.); +#10632 = EDGE_LOOP('',(#10633,#10656,#10657,#10658)); +#10633 = ORIENTED_EDGE('',*,*,#10634,.F.); +#10634 = EDGE_CURVE('',#10586,#10635,#10637,.T.); +#10635 = VERTEX_POINT('',#10636); +#10636 = CARTESIAN_POINT('',(-9.8,53.799999999986,36.5)); +#10637 = SURFACE_CURVE('',#10638,(#10642,#10649),.PCURVE_S1.); +#10638 = LINE('',#10639,#10640); +#10639 = CARTESIAN_POINT('',(-9.8,26.899999999992,36.5)); +#10640 = VECTOR('',#10641,1.); +#10641 = DIRECTION('',(2.925369900452E-42,-1.,1.798273018971E-15)); +#10642 = PCURVE('',#6716,#10643); +#10643 = DEFINITIONAL_REPRESENTATION('',(#10644),#10648); +#10644 = LINE('',#10645,#10646); +#10645 = CARTESIAN_POINT('',(-26.89999999999,2.)); +#10646 = VECTOR('',#10647,1.); +#10647 = DIRECTION('',(-1.,3.048813858882E-16)); +#10648 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10649 = PCURVE('',#2685,#10650); +#10650 = DEFINITIONAL_REPRESENTATION('',(#10651),#10655); +#10651 = LINE('',#10652,#10653); +#10652 = CARTESIAN_POINT('',(-7.80000000001,26.899999999994)); +#10653 = VECTOR('',#10654,1.); +#10654 = DIRECTION('',(1.707552736872E-30,-1.)); +#10655 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10656 = ORIENTED_EDGE('',*,*,#10610,.F.); +#10657 = ORIENTED_EDGE('',*,*,#6700,.F.); +#10658 = ORIENTED_EDGE('',*,*,#10659,.T.); +#10659 = EDGE_CURVE('',#6673,#10635,#10660,.T.); +#10660 = SURFACE_CURVE('',#10661,(#10665,#10672),.PCURVE_S1.); +#10661 = LINE('',#10662,#10663); +#10662 = CARTESIAN_POINT('',(-9.8,53.799999999986,38.5)); +#10663 = VECTOR('',#10664,1.); +#10664 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10665 = PCURVE('',#6716,#10666); +#10666 = DEFINITIONAL_REPRESENTATION('',(#10667),#10671); +#10667 = LINE('',#10668,#10669); +#10668 = CARTESIAN_POINT('',(0.,0.)); +#10669 = VECTOR('',#10670,1.); +#10670 = DIRECTION('',(-2.894979576369E-17,1.)); +#10671 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10672 = PCURVE('',#6688,#10673); +#10673 = DEFINITIONAL_REPRESENTATION('',(#10674),#10678); +#10674 = LINE('',#10675,#10676); +#10675 = CARTESIAN_POINT('',(25.600000000046,-1.45862047238E-26)); +#10676 = VECTOR('',#10677,1.); +#10677 = DIRECTION('',(-1.450192893823E-27,1.)); +#10678 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10679 = ADVANCED_FACE('',(#10680),#6688,.F.); +#10680 = FACE_BOUND('',#10681,.T.); +#10681 = EDGE_LOOP('',(#10682,#10703,#10704,#10705)); +#10682 = ORIENTED_EDGE('',*,*,#10683,.F.); +#10683 = EDGE_CURVE('',#10635,#10515,#10684,.T.); +#10684 = SURFACE_CURVE('',#10685,(#10689,#10696),.PCURVE_S1.); +#10685 = LINE('',#10686,#10687); +#10686 = CARTESIAN_POINT('',(6.900000000055,53.799999999969,36.5)); +#10687 = VECTOR('',#10688,1.); +#10688 = DIRECTION('',(1.,-1.009609063017E-12,1.018942737708E-15)); +#10689 = PCURVE('',#6688,#10690); +#10690 = DEFINITIONAL_REPRESENTATION('',(#10691),#10695); +#10691 = LINE('',#10692,#10693); +#10692 = CARTESIAN_POINT('',(8.899999999991,2.)); +#10693 = VECTOR('',#10694,1.); +#10694 = DIRECTION('',(-1.,-1.018942737708E-15)); +#10695 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10696 = PCURVE('',#2685,#10697); +#10697 = DEFINITIONAL_REPRESENTATION('',(#10698),#10702); +#10698 = LINE('',#10699,#10700); +#10699 = CARTESIAN_POINT('',(8.900000000045,53.79999999997)); +#10700 = VECTOR('',#10701,1.); +#10701 = DIRECTION('',(1.,-1.009609063017E-12)); +#10702 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10703 = ORIENTED_EDGE('',*,*,#10659,.F.); +#10704 = ORIENTED_EDGE('',*,*,#6672,.F.); +#10705 = ORIENTED_EDGE('',*,*,#10539,.T.); +#10706 = ADVANCED_FACE('',(#10707),#6773,.F.); +#10707 = FACE_BOUND('',#10708,.F.); +#10708 = EDGE_LOOP('',(#10709,#10732,#10754,#10755)); +#10709 = ORIENTED_EDGE('',*,*,#10710,.T.); +#10710 = EDGE_CURVE('',#6757,#10711,#10713,.T.); +#10711 = VERTEX_POINT('',#10712); +#10712 = CARTESIAN_POINT('',(1.05,-4.07560361699E-15,36.5)); +#10713 = SEAM_CURVE('',#10714,(#10718,#10725),.PCURVE_S1.); +#10714 = LINE('',#10715,#10716); +#10715 = CARTESIAN_POINT('',(1.05,-1.264706351001E-16,38.5)); +#10716 = VECTOR('',#10717,1.); +#10717 = DIRECTION('',(-6.616465975138E-29,-2.103154404859E-15,-1.)); +#10718 = PCURVE('',#6773,#10719); +#10719 = DEFINITIONAL_REPRESENTATION('',(#10720),#10724); +#10720 = LINE('',#10721,#10722); +#10721 = CARTESIAN_POINT('',(9.424777960769,5.093855196671E-31)); +#10722 = VECTOR('',#10723,1.); +#10723 = DIRECTION('',(0.,1.)); +#10724 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10725 = PCURVE('',#6773,#10726); +#10726 = DEFINITIONAL_REPRESENTATION('',(#10727),#10731); +#10727 = LINE('',#10728,#10729); +#10728 = CARTESIAN_POINT('',(3.14159265359,5.093855196671E-31)); +#10729 = VECTOR('',#10730,1.); +#10730 = DIRECTION('',(0.,1.)); +#10731 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10732 = ORIENTED_EDGE('',*,*,#10733,.T.); +#10733 = EDGE_CURVE('',#10711,#10711,#10734,.T.); +#10734 = SURFACE_CURVE('',#10735,(#10740,#10747),.PCURVE_S1.); +#10735 = CIRCLE('',#10736,1.05); +#10736 = AXIS2_PLACEMENT_3D('',#10737,#10738,#10739); +#10737 = CARTESIAN_POINT('',(0.,-4.2041915309E-15,36.5)); +#10738 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#10739 = DIRECTION('',(-1.,-1.832337233097E-30,-1.018942737707E-15)); +#10740 = PCURVE('',#6773,#10741); +#10741 = DEFINITIONAL_REPRESENTATION('',(#10742),#10746); +#10742 = LINE('',#10743,#10744); +#10743 = CARTESIAN_POINT('',(12.566370614359,2.)); +#10744 = VECTOR('',#10745,1.); +#10745 = DIRECTION('',(-1.,0.)); +#10746 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10747 = PCURVE('',#2685,#10748); +#10748 = DEFINITIONAL_REPRESENTATION('',(#10749),#10753); +#10749 = CIRCLE('',#10750,1.05); +#10750 = AXIS2_PLACEMENT_2D('',#10751,#10752); +#10751 = CARTESIAN_POINT('',(1.999999999991,1.391612027387E-12)); +#10752 = DIRECTION('',(-1.,-1.707552736872E-30)); +#10753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10754 = ORIENTED_EDGE('',*,*,#10710,.F.); +#10755 = ORIENTED_EDGE('',*,*,#6756,.T.); +#10756 = ADVANCED_FACE('',(#10757),#6804,.F.); +#10757 = FACE_BOUND('',#10758,.F.); +#10758 = EDGE_LOOP('',(#10759,#10782,#10804,#10805)); +#10759 = ORIENTED_EDGE('',*,*,#10760,.T.); +#10760 = EDGE_CURVE('',#6788,#10761,#10763,.T.); +#10761 = VERTEX_POINT('',#10762); +#10762 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,36.5)); +#10763 = SEAM_CURVE('',#10764,(#10768,#10775),.PCURVE_S1.); +#10764 = LINE('',#10765,#10766); +#10765 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,38.5)); +#10766 = VECTOR('',#10767,1.); +#10767 = DIRECTION('',(-6.616465975138E-29,-2.132104200623E-15,-1.)); +#10768 = PCURVE('',#6804,#10769); +#10769 = DEFINITIONAL_REPRESENTATION('',(#10770),#10774); +#10770 = LINE('',#10771,#10772); +#10771 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10772 = VECTOR('',#10773,1.); +#10773 = DIRECTION('',(3.330669073876E-15,1.)); +#10774 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10775 = PCURVE('',#6804,#10776); +#10776 = DEFINITIONAL_REPRESENTATION('',(#10777),#10781); +#10777 = LINE('',#10778,#10779); +#10778 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#10779 = VECTOR('',#10780,1.); +#10780 = DIRECTION('',(3.330669073876E-15,1.)); +#10781 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10782 = ORIENTED_EDGE('',*,*,#10783,.T.); +#10783 = EDGE_CURVE('',#10761,#10761,#10784,.T.); +#10784 = SURFACE_CURVE('',#10785,(#10790,#10797),.PCURVE_S1.); +#10785 = CIRCLE('',#10786,1.05); +#10786 = AXIS2_PLACEMENT_3D('',#10787,#10788,#10789); +#10787 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,36.5)); +#10788 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#10789 = DIRECTION('',(-1.,-1.832337233097E-30,-1.018942737707E-15)); +#10790 = PCURVE('',#6804,#10791); +#10791 = DEFINITIONAL_REPRESENTATION('',(#10792),#10796); +#10792 = LINE('',#10793,#10794); +#10793 = CARTESIAN_POINT('',(6.28318530718,2.)); +#10794 = VECTOR('',#10795,1.); +#10795 = DIRECTION('',(-1.,0.)); +#10796 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10797 = PCURVE('',#2685,#10798); +#10798 = DEFINITIONAL_REPRESENTATION('',(#10799),#10803); +#10799 = CIRCLE('',#10800,1.05); +#10800 = AXIS2_PLACEMENT_2D('',#10801,#10802); +#10801 = CARTESIAN_POINT('',(16.511112605602,-41.73651813908)); +#10802 = DIRECTION('',(-1.,-1.707552736872E-30)); +#10803 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10804 = ORIENTED_EDGE('',*,*,#10760,.F.); +#10805 = ORIENTED_EDGE('',*,*,#6787,.T.); +#10806 = ADVANCED_FACE('',(#10807),#8423,.F.); +#10807 = FACE_BOUND('',#10808,.F.); +#10808 = EDGE_LOOP('',(#10809,#10832,#10854,#10855)); +#10809 = ORIENTED_EDGE('',*,*,#10810,.T.); +#10810 = EDGE_CURVE('',#8407,#10811,#10813,.T.); +#10811 = VERTEX_POINT('',#10812); +#10812 = CARTESIAN_POINT('',(27.000000000023,31.949999999942, + 24.499999999965)); +#10813 = SEAM_CURVE('',#10814,(#10818,#10825),.PCURVE_S1.); +#10814 = LINE('',#10815,#10816); +#10815 = CARTESIAN_POINT('',(29.000000000023,31.949999999942, + 24.499999999965)); +#10816 = VECTOR('',#10817,1.); +#10817 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#10818 = PCURVE('',#8423,#10819); +#10819 = DEFINITIONAL_REPRESENTATION('',(#10820),#10824); +#10820 = LINE('',#10821,#10822); +#10821 = CARTESIAN_POINT('',(9.424777960769,0.)); +#10822 = VECTOR('',#10823,1.); +#10823 = DIRECTION('',(0.,1.)); +#10824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10825 = PCURVE('',#8423,#10826); +#10826 = DEFINITIONAL_REPRESENTATION('',(#10827),#10831); +#10827 = LINE('',#10828,#10829); +#10828 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10829 = VECTOR('',#10830,1.); +#10830 = DIRECTION('',(0.,1.)); +#10831 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10832 = ORIENTED_EDGE('',*,*,#10833,.T.); +#10833 = EDGE_CURVE('',#10811,#10811,#10834,.T.); +#10834 = SURFACE_CURVE('',#10835,(#10840,#10847),.PCURVE_S1.); +#10835 = CIRCLE('',#10836,1.05); +#10836 = AXIS2_PLACEMENT_3D('',#10837,#10838,#10839); +#10837 = CARTESIAN_POINT('',(27.000000000023,32.999999999942, + 24.499999999965)); +#10838 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#10839 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#10840 = PCURVE('',#8423,#10841); +#10841 = DEFINITIONAL_REPRESENTATION('',(#10842),#10846); +#10842 = LINE('',#10843,#10844); +#10843 = CARTESIAN_POINT('',(12.566370614359,2.)); +#10844 = VECTOR('',#10845,1.); +#10845 = DIRECTION('',(-1.,0.)); +#10846 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10847 = PCURVE('',#4150,#10848); +#10848 = DEFINITIONAL_REPRESENTATION('',(#10849),#10853); +#10849 = CIRCLE('',#10850,1.05); +#10850 = AXIS2_PLACEMENT_2D('',#10851,#10852); +#10851 = CARTESIAN_POINT('',(97.59999999994,19.999999999965)); +#10852 = DIRECTION('',(1.,0.)); +#10853 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10854 = ORIENTED_EDGE('',*,*,#10810,.F.); +#10855 = ORIENTED_EDGE('',*,*,#8406,.T.); +#10856 = ADVANCED_FACE('',(#10857),#8454,.F.); +#10857 = FACE_BOUND('',#10858,.F.); +#10858 = EDGE_LOOP('',(#10859,#10882,#10904,#10905)); +#10859 = ORIENTED_EDGE('',*,*,#10860,.T.); +#10860 = EDGE_CURVE('',#8438,#10861,#10863,.T.); +#10861 = VERTEX_POINT('',#10862); +#10862 = CARTESIAN_POINT('',(27.000000000023,-34.05000000005, + 24.499999999965)); +#10863 = SEAM_CURVE('',#10864,(#10868,#10875),.PCURVE_S1.); +#10864 = LINE('',#10865,#10866); +#10865 = CARTESIAN_POINT('',(29.000000000023,-34.05000000005, + 24.499999999965)); +#10866 = VECTOR('',#10867,1.); +#10867 = DIRECTION('',(-1.,8.10283387812E-45,6.616465975138E-29)); +#10868 = PCURVE('',#8454,#10869); +#10869 = DEFINITIONAL_REPRESENTATION('',(#10870),#10874); +#10870 = LINE('',#10871,#10872); +#10871 = CARTESIAN_POINT('',(9.424777960769,0.)); +#10872 = VECTOR('',#10873,1.); +#10873 = DIRECTION('',(0.,1.)); +#10874 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10875 = PCURVE('',#8454,#10876); +#10876 = DEFINITIONAL_REPRESENTATION('',(#10877),#10881); +#10877 = LINE('',#10878,#10879); +#10878 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10879 = VECTOR('',#10880,1.); +#10880 = DIRECTION('',(0.,1.)); +#10881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10882 = ORIENTED_EDGE('',*,*,#10883,.T.); +#10883 = EDGE_CURVE('',#10861,#10861,#10884,.T.); +#10884 = SURFACE_CURVE('',#10885,(#10890,#10897),.PCURVE_S1.); +#10885 = CIRCLE('',#10886,1.05); +#10886 = AXIS2_PLACEMENT_3D('',#10887,#10888,#10889); +#10887 = CARTESIAN_POINT('',(27.000000000023,-33.00000000005, + 24.499999999965)); +#10888 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#10889 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#10890 = PCURVE('',#8454,#10891); +#10891 = DEFINITIONAL_REPRESENTATION('',(#10892),#10896); +#10892 = LINE('',#10893,#10894); +#10893 = CARTESIAN_POINT('',(12.566370614359,2.)); +#10894 = VECTOR('',#10895,1.); +#10895 = DIRECTION('',(-1.,0.)); +#10896 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10897 = PCURVE('',#3926,#10898); +#10898 = DEFINITIONAL_REPRESENTATION('',(#10899),#10903); +#10899 = CIRCLE('',#10900,1.05); +#10900 = AXIS2_PLACEMENT_2D('',#10901,#10902); +#10901 = CARTESIAN_POINT('',(31.59999999994,19.999999999965)); +#10902 = DIRECTION('',(1.,0.)); +#10903 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10904 = ORIENTED_EDGE('',*,*,#10860,.F.); +#10905 = ORIENTED_EDGE('',*,*,#8437,.T.); +#10906 = ADVANCED_FACE('',(#10907),#4292,.F.); +#10907 = FACE_BOUND('',#10908,.F.); +#10908 = EDGE_LOOP('',(#10909,#10930,#10931,#10932)); +#10909 = ORIENTED_EDGE('',*,*,#10910,.T.); +#10910 = EDGE_CURVE('',#4272,#6819,#10911,.T.); +#10911 = SEAM_CURVE('',#10912,(#10916,#10923),.PCURVE_S1.); +#10912 = LINE('',#10913,#10914); +#10913 = CARTESIAN_POINT('',(-31.05000000007,61.599999999999,38.5)); +#10914 = VECTOR('',#10915,1.); +#10915 = DIRECTION('',(1.567230213877E-27,-6.669143989382E-17,1.)); +#10916 = PCURVE('',#4292,#10917); +#10917 = DEFINITIONAL_REPRESENTATION('',(#10918),#10922); +#10918 = LINE('',#10919,#10920); +#10919 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#10920 = VECTOR('',#10921,1.); +#10921 = DIRECTION('',(0.,-1.)); +#10922 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10923 = PCURVE('',#4292,#10924); +#10924 = DEFINITIONAL_REPRESENTATION('',(#10925),#10929); +#10925 = LINE('',#10926,#10927); +#10926 = CARTESIAN_POINT('',(3.14159265359,0.)); +#10927 = VECTOR('',#10928,1.); +#10928 = DIRECTION('',(0.,-1.)); +#10929 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10930 = ORIENTED_EDGE('',*,*,#6818,.T.); +#10931 = ORIENTED_EDGE('',*,*,#10910,.F.); +#10932 = ORIENTED_EDGE('',*,*,#4271,.F.); +#10933 = ADVANCED_FACE('',(#10934),#2711,.T.); +#10934 = FACE_BOUND('',#10935,.T.); +#10935 = EDGE_LOOP('',(#10936,#10937,#10960,#10981)); +#10936 = ORIENTED_EDGE('',*,*,#2697,.F.); +#10937 = ORIENTED_EDGE('',*,*,#10938,.F.); +#10938 = EDGE_CURVE('',#10939,#2669,#10941,.T.); +#10939 = VERTEX_POINT('',#10940); +#10940 = CARTESIAN_POINT('',(-31.,58.599999999999,36.5)); +#10941 = SURFACE_CURVE('',#10942,(#10946,#10953),.PCURVE_S1.); +#10942 = LINE('',#10943,#10944); +#10943 = CARTESIAN_POINT('',(-14.50000000007,58.600000000023,36.5)); +#10944 = VECTOR('',#10945,1.); +#10945 = DIRECTION('',(1.,1.443734394282E-12,1.018942737704E-15)); +#10946 = PCURVE('',#2711,#10947); +#10947 = DEFINITIONAL_REPRESENTATION('',(#10948),#10952); +#10948 = LINE('',#10949,#10950); +#10949 = CARTESIAN_POINT('',(-12.49999999999,2.)); +#10950 = VECTOR('',#10951,1.); +#10951 = DIRECTION('',(-1.,-1.018942737704E-15)); +#10952 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10953 = PCURVE('',#2685,#10954); +#10954 = DEFINITIONAL_REPRESENTATION('',(#10955),#10959); +#10955 = LINE('',#10956,#10957); +#10956 = CARTESIAN_POINT('',(-12.50000000008,58.600000000024)); +#10957 = VECTOR('',#10958,1.); +#10958 = DIRECTION('',(1.,1.443734394282E-12)); +#10959 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10960 = ORIENTED_EDGE('',*,*,#10961,.F.); +#10961 = EDGE_CURVE('',#2804,#10939,#10962,.T.); +#10962 = SURFACE_CURVE('',#10963,(#10967,#10974),.PCURVE_S1.); +#10963 = LINE('',#10964,#10965); +#10964 = CARTESIAN_POINT('',(-31.,58.599999999999,21.5)); +#10965 = VECTOR('',#10966,1.); +#10966 = DIRECTION('',(6.505001528348E-29,-6.669143989382E-17,1.)); +#10967 = PCURVE('',#2711,#10968); +#10968 = DEFINITIONAL_REPRESENTATION('',(#10969),#10973); +#10969 = LINE('',#10970,#10971); +#10970 = CARTESIAN_POINT('',(3.999999999934,17.)); +#10971 = VECTOR('',#10972,1.); +#10972 = DIRECTION('',(8.121528094658E-29,-1.)); +#10973 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10974 = PCURVE('',#2842,#10975); +#10975 = DEFINITIONAL_REPRESENTATION('',(#10976),#10980); +#10976 = LINE('',#10977,#10978); +#10977 = CARTESIAN_POINT('',(5.999999999997,17.)); +#10978 = VECTOR('',#10979,1.); +#10979 = DIRECTION('',(1.891561198086E-16,1.)); +#10980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10981 = ORIENTED_EDGE('',*,*,#2803,.T.); +#10982 = ADVANCED_FACE('',(#10983),#4389,.F.); +#10983 = FACE_BOUND('',#10984,.F.); +#10984 = EDGE_LOOP('',(#10985,#11006,#11007,#11008)); +#10985 = ORIENTED_EDGE('',*,*,#10986,.T.); +#10986 = EDGE_CURVE('',#4373,#6845,#10987,.T.); +#10987 = SEAM_CURVE('',#10988,(#10992,#10999),.PCURVE_S1.); +#10988 = LINE('',#10989,#10990); +#10989 = CARTESIAN_POINT('',(27.050000000019,61.599999999999,38.5)); +#10990 = VECTOR('',#10991,1.); +#10991 = DIRECTION('',(-1.432541048686E-27,-6.669143989382E-17,1.)); +#10992 = PCURVE('',#4389,#10993); +#10993 = DEFINITIONAL_REPRESENTATION('',(#10994),#10998); +#10994 = LINE('',#10995,#10996); +#10995 = CARTESIAN_POINT('',(9.424777960769,0.)); +#10996 = VECTOR('',#10997,1.); +#10997 = DIRECTION('',(0.,1.)); +#10998 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#10999 = PCURVE('',#4389,#11000); +#11000 = DEFINITIONAL_REPRESENTATION('',(#11001),#11005); +#11001 = LINE('',#11002,#11003); +#11002 = CARTESIAN_POINT('',(3.14159265359,0.)); +#11003 = VECTOR('',#11004,1.); +#11004 = DIRECTION('',(0.,1.)); +#11005 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11006 = ORIENTED_EDGE('',*,*,#6844,.F.); +#11007 = ORIENTED_EDGE('',*,*,#10986,.F.); +#11008 = ORIENTED_EDGE('',*,*,#4372,.T.); +#11009 = ADVANCED_FACE('',(#11010),#4235,.F.); +#11010 = FACE_BOUND('',#11011,.T.); +#11011 = EDGE_LOOP('',(#11012,#11013,#11036,#11057)); +#11012 = ORIENTED_EDGE('',*,*,#4452,.F.); +#11013 = ORIENTED_EDGE('',*,*,#11014,.F.); +#11014 = EDGE_CURVE('',#11015,#4429,#11017,.T.); +#11015 = VERTEX_POINT('',#11016); +#11016 = CARTESIAN_POINT('',(23.00000000002,62.599999999996,36.5)); +#11017 = SURFACE_CURVE('',#11018,(#11022,#11029),.PCURVE_S1.); +#11018 = LINE('',#11019,#11020); +#11019 = CARTESIAN_POINT('',(22.999999999977,32.299999999984,36.5)); +#11020 = VECTOR('',#11021,1.); +#11021 = DIRECTION('',(-1.428931420621E-12,-1.,1.798273018969E-15)); +#11022 = PCURVE('',#4235,#11023); +#11023 = DEFINITIONAL_REPRESENTATION('',(#11024),#11028); +#11024 = LINE('',#11025,#11026); +#11025 = CARTESIAN_POINT('',(32.300000000021,2.)); +#11026 = VECTOR('',#11027,1.); +#11027 = DIRECTION('',(1.,-1.945807296752E-15)); +#11028 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11029 = PCURVE('',#2685,#11030); +#11030 = DEFINITIONAL_REPRESENTATION('',(#11031),#11035); +#11031 = LINE('',#11032,#11033); +#11032 = CARTESIAN_POINT('',(24.999999999967,32.299999999985)); +#11033 = VECTOR('',#11034,1.); +#11034 = DIRECTION('',(-1.428931420621E-12,-1.)); +#11035 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11036 = ORIENTED_EDGE('',*,*,#11037,.F.); +#11037 = EDGE_CURVE('',#4220,#11015,#11038,.T.); +#11038 = SURFACE_CURVE('',#11039,(#11043,#11050),.PCURVE_S1.); +#11039 = LINE('',#11040,#11041); +#11040 = CARTESIAN_POINT('',(23.00000000002,62.599999999996, + 28.324999999993)); +#11041 = VECTOR('',#11042,1.); +#11042 = DIRECTION('',(-1.162249925689E-27,1.224646799147E-16,1.)); +#11043 = PCURVE('',#4235,#11044); +#11044 = DEFINITIONAL_REPRESENTATION('',(#11045),#11049); +#11045 = LINE('',#11046,#11047); +#11046 = CARTESIAN_POINT('',(2.000000000009,10.175000000007)); +#11047 = VECTOR('',#11048,1.); +#11048 = DIRECTION('',(-2.699989576978E-16,-1.)); +#11049 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11050 = PCURVE('',#2766,#11051); +#11051 = DEFINITIONAL_REPRESENTATION('',(#11052),#11056); +#11052 = LINE('',#11053,#11054); +#11053 = CARTESIAN_POINT('',(-10.175,45.700000000034)); +#11054 = VECTOR('',#11055,1.); +#11055 = DIRECTION('',(-1.,-1.22841458544E-27)); +#11056 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11057 = ORIENTED_EDGE('',*,*,#4219,.F.); +#11058 = ADVANCED_FACE('',(#11059),#4358,.F.); +#11059 = FACE_BOUND('',#11060,.F.); +#11060 = EDGE_LOOP('',(#11061,#11082,#11083,#11084)); +#11061 = ORIENTED_EDGE('',*,*,#11062,.T.); +#11062 = EDGE_CURVE('',#4342,#6875,#11063,.T.); +#11063 = SEAM_CURVE('',#11064,(#11068,#11075),.PCURVE_S1.); +#11064 = LINE('',#11065,#11066); +#11065 = CARTESIAN_POINT('',(-31.05000000016,-61.60000000002,38.5)); +#11066 = VECTOR('',#11067,1.); +#11067 = DIRECTION('',(3.065935922314E-27,2.02231156697E-15,1.)); +#11068 = PCURVE('',#4358,#11069); +#11069 = DEFINITIONAL_REPRESENTATION('',(#11070),#11074); +#11070 = LINE('',#11071,#11072); +#11071 = CARTESIAN_POINT('',(3.14159265359,0.)); +#11072 = VECTOR('',#11073,1.); +#11073 = DIRECTION('',(0.,1.)); +#11074 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11075 = PCURVE('',#4358,#11076); +#11076 = DEFINITIONAL_REPRESENTATION('',(#11077),#11081); +#11077 = LINE('',#11078,#11079); +#11078 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#11079 = VECTOR('',#11080,1.); +#11080 = DIRECTION('',(0.,1.)); +#11081 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11082 = ORIENTED_EDGE('',*,*,#6874,.F.); +#11083 = ORIENTED_EDGE('',*,*,#11062,.F.); +#11084 = ORIENTED_EDGE('',*,*,#4341,.T.); +#11085 = ADVANCED_FACE('',(#11086),#4327,.F.); +#11086 = FACE_BOUND('',#11087,.F.); +#11087 = EDGE_LOOP('',(#11088,#11109,#11110,#11111)); +#11088 = ORIENTED_EDGE('',*,*,#11089,.T.); +#11089 = EDGE_CURVE('',#4307,#6905,#11090,.T.); +#11090 = SEAM_CURVE('',#11091,(#11095,#11102),.PCURVE_S1.); +#11091 = LINE('',#11092,#11093); +#11092 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011,38.5)); +#11093 = VECTOR('',#11094,1.); +#11094 = DIRECTION('',(6.616465975138E-29,2.02231156697E-15,1.)); +#11095 = PCURVE('',#4327,#11096); +#11096 = DEFINITIONAL_REPRESENTATION('',(#11097),#11101); +#11097 = LINE('',#11098,#11099); +#11098 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#11099 = VECTOR('',#11100,1.); +#11100 = DIRECTION('',(0.,-1.)); +#11101 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11102 = PCURVE('',#4327,#11103); +#11103 = DEFINITIONAL_REPRESENTATION('',(#11104),#11108); +#11104 = LINE('',#11105,#11106); +#11105 = CARTESIAN_POINT('',(3.14159265359,0.)); +#11106 = VECTOR('',#11107,1.); +#11107 = DIRECTION('',(0.,-1.)); +#11108 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11109 = ORIENTED_EDGE('',*,*,#6904,.T.); +#11110 = ORIENTED_EDGE('',*,*,#11089,.F.); +#11111 = ORIENTED_EDGE('',*,*,#4306,.F.); +#11112 = ADVANCED_FACE('',(#11113),#2842,.F.); +#11113 = FACE_BOUND('',#11114,.T.); +#11114 = EDGE_LOOP('',(#11115,#11116,#11139,#11160)); +#11115 = ORIENTED_EDGE('',*,*,#10961,.T.); +#11116 = ORIENTED_EDGE('',*,*,#11117,.F.); +#11117 = EDGE_CURVE('',#11118,#10939,#11120,.T.); +#11118 = VERTEX_POINT('',#11119); +#11119 = CARTESIAN_POINT('',(-31.,40.599999999996,36.5)); +#11120 = SURFACE_CURVE('',#11121,(#11125,#11132),.PCURVE_S1.); +#11121 = LINE('',#11122,#11123); +#11122 = CARTESIAN_POINT('',(-31.,32.299999999997,36.5)); +#11123 = VECTOR('',#11124,1.); +#11124 = DIRECTION('',(5.892722207626E-15,1.,-1.798273018971E-15)); +#11125 = PCURVE('',#2842,#11126); +#11126 = DEFINITIONAL_REPRESENTATION('',(#11127),#11131); +#11127 = LINE('',#11128,#11129); +#11128 = CARTESIAN_POINT('',(32.299999999998,32.)); +#11129 = VECTOR('',#11130,1.); +#11130 = DIRECTION('',(-1.,-1.675808339056E-15)); +#11131 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11132 = PCURVE('',#2685,#11133); +#11133 = DEFINITIONAL_REPRESENTATION('',(#11134),#11138); +#11134 = LINE('',#11135,#11136); +#11135 = CARTESIAN_POINT('',(-29.00000000001,32.299999999999)); +#11136 = VECTOR('',#11137,1.); +#11137 = DIRECTION('',(5.892722207626E-15,1.)); +#11138 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11139 = ORIENTED_EDGE('',*,*,#11140,.T.); +#11140 = EDGE_CURVE('',#11118,#2827,#11141,.T.); +#11141 = SURFACE_CURVE('',#11142,(#11146,#11153),.PCURVE_S1.); +#11142 = LINE('',#11143,#11144); +#11143 = CARTESIAN_POINT('',(-31.,40.599999999996,4.5)); +#11144 = VECTOR('',#11145,1.); +#11145 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#11146 = PCURVE('',#2842,#11147); +#11147 = DEFINITIONAL_REPRESENTATION('',(#11148),#11152); +#11148 = LINE('',#11149,#11150); +#11149 = CARTESIAN_POINT('',(24.,1.127170239725E-14)); +#11150 = VECTOR('',#11151,1.); +#11151 = DIRECTION('',(0.,-1.)); +#11152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11153 = PCURVE('',#2870,#11154); +#11154 = DEFINITIONAL_REPRESENTATION('',(#11155),#11159); +#11155 = LINE('',#11156,#11157); +#11156 = CARTESIAN_POINT('',(2.,2.655288028925E-28)); +#11157 = VECTOR('',#11158,1.); +#11158 = DIRECTION('',(0.,-1.)); +#11159 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11160 = ORIENTED_EDGE('',*,*,#2826,.F.); +#11161 = ADVANCED_FACE('',(#11162,#11188,#11282,#11399,#11493,#11610, + #11704,#11775,#11869,#11963,#12057,#12151,#12245),#2766,.T.); +#11162 = FACE_BOUND('',#11163,.T.); +#11163 = EDGE_LOOP('',(#11164,#11165,#11166,#11167)); +#11164 = ORIENTED_EDGE('',*,*,#2750,.T.); +#11165 = ORIENTED_EDGE('',*,*,#4247,.T.); +#11166 = ORIENTED_EDGE('',*,*,#11037,.T.); +#11167 = ORIENTED_EDGE('',*,*,#11168,.T.); +#11168 = EDGE_CURVE('',#11015,#2751,#11169,.T.); +#11169 = SURFACE_CURVE('',#11170,(#11174,#11181),.PCURVE_S1.); +#11170 = LINE('',#11171,#11172); +#11171 = CARTESIAN_POINT('',(-12.35,62.599999999996,36.5)); +#11172 = VECTOR('',#11173,1.); +#11173 = DIRECTION('',(-1.,-4.440892098501E-15,-1.018942737706E-15)); +#11174 = PCURVE('',#2766,#11175); +#11175 = DEFINITIONAL_REPRESENTATION('',(#11176),#11180); +#11176 = LINE('',#11177,#11178); +#11177 = CARTESIAN_POINT('',(-18.35000000001,10.350000000012)); +#11178 = VECTOR('',#11179,1.); +#11179 = DIRECTION('',(1.018942737707E-15,-1.)); +#11180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11181 = PCURVE('',#2685,#11182); +#11182 = DEFINITIONAL_REPRESENTATION('',(#11183),#11187); +#11183 = LINE('',#11184,#11185); +#11184 = CARTESIAN_POINT('',(-10.35000000001,62.599999999997)); +#11185 = VECTOR('',#11186,1.); +#11186 = DIRECTION('',(-1.,-4.440892098501E-15)); +#11187 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11188 = FACE_BOUND('',#11189,.T.); +#11189 = EDGE_LOOP('',(#11190,#11215,#11238,#11261)); +#11190 = ORIENTED_EDGE('',*,*,#11191,.T.); +#11191 = EDGE_CURVE('',#11192,#11194,#11196,.T.); +#11192 = VERTEX_POINT('',#11193); +#11193 = CARTESIAN_POINT('',(16.449999999975,62.599999999996,31.5)); +#11194 = VERTEX_POINT('',#11195); +#11195 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 25.949999999952)); +#11196 = SURFACE_CURVE('',#11197,(#11201,#11208),.PCURVE_S1.); +#11197 = LINE('',#11198,#11199); +#11198 = CARTESIAN_POINT('',(16.149999999975,62.599999999996,31.8)); +#11199 = VECTOR('',#11200,1.); +#11200 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11201 = PCURVE('',#2766,#11202); +#11202 = DEFINITIONAL_REPRESENTATION('',(#11203),#11207); +#11203 = LINE('',#11204,#11205); +#11204 = CARTESIAN_POINT('',(-13.65000000001,38.849999999989)); +#11205 = VECTOR('',#11206,1.); +#11206 = DIRECTION('',(0.707106781187,0.707106781187)); +#11207 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11208 = PCURVE('',#8703,#11209); +#11209 = DEFINITIONAL_REPRESENTATION('',(#11210),#11214); +#11210 = LINE('',#11211,#11212); +#11211 = CARTESIAN_POINT('',(1.712110193826E-15,2.)); +#11212 = VECTOR('',#11213,1.); +#11213 = DIRECTION('',(1.,-4.361251546428E-31)); +#11214 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11215 = ORIENTED_EDGE('',*,*,#11216,.T.); +#11216 = EDGE_CURVE('',#11194,#11217,#11219,.T.); +#11217 = VERTEX_POINT('',#11218); +#11218 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 22.949999999951)); +#11219 = SURFACE_CURVE('',#11220,(#11224,#11231),.PCURVE_S1.); +#11220 = LINE('',#11221,#11222); +#11221 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,31.5)); +#11222 = VECTOR('',#11223,1.); +#11223 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#11224 = PCURVE('',#2766,#11225); +#11225 = DEFINITIONAL_REPRESENTATION('',(#11226),#11230); +#11226 = LINE('',#11227,#11228); +#11227 = CARTESIAN_POINT('',(-13.35000000001,44.700000000037)); +#11228 = VECTOR('',#11229,1.); +#11229 = DIRECTION('',(1.,-3.996345356033E-31)); +#11230 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11231 = PCURVE('',#8677,#11232); +#11232 = DEFINITIONAL_REPRESENTATION('',(#11233),#11237); +#11233 = LINE('',#11234,#11235); +#11234 = CARTESIAN_POINT('',(3.740318654202E-15,2.)); +#11235 = VECTOR('',#11236,1.); +#11236 = DIRECTION('',(1.,3.944304526105E-31)); +#11237 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11238 = ORIENTED_EDGE('',*,*,#11239,.T.); +#11239 = EDGE_CURVE('',#11217,#11240,#11242,.T.); +#11240 = VERTEX_POINT('',#11241); +#11241 = CARTESIAN_POINT('',(13.449999999975,62.599999999996,31.5)); +#11242 = SURFACE_CURVE('',#11243,(#11247,#11254),.PCURVE_S1.); +#11243 = LINE('',#11244,#11245); +#11244 = CARTESIAN_POINT('',(13.149999999975,62.599999999996,31.8)); +#11245 = VECTOR('',#11246,1.); +#11246 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11247 = PCURVE('',#2766,#11248); +#11248 = DEFINITIONAL_REPRESENTATION('',(#11249),#11253); +#11249 = LINE('',#11250,#11251); +#11250 = CARTESIAN_POINT('',(-13.65000000001,35.849999999989)); +#11251 = VECTOR('',#11252,1.); +#11252 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11253 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11254 = PCURVE('',#8649,#11255); +#11255 = DEFINITIONAL_REPRESENTATION('',(#11256),#11260); +#11256 = LINE('',#11257,#11258); +#11257 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11258 = VECTOR('',#11259,1.); +#11259 = DIRECTION('',(1.,3.871099052181E-31)); +#11260 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11261 = ORIENTED_EDGE('',*,*,#11262,.T.); +#11262 = EDGE_CURVE('',#11240,#11192,#11263,.T.); +#11263 = SURFACE_CURVE('',#11264,(#11268,#11275),.PCURVE_S1.); +#11264 = LINE('',#11265,#11266); +#11265 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11266 = VECTOR('',#11267,1.); +#11267 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#11268 = PCURVE('',#2766,#11269); +#11269 = DEFINITIONAL_REPRESENTATION('',(#11270),#11274); +#11270 = LINE('',#11271,#11272); +#11271 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#11272 = VECTOR('',#11273,1.); +#11273 = DIRECTION('',(0.,1.)); +#11274 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11275 = PCURVE('',#8621,#11276); +#11276 = DEFINITIONAL_REPRESENTATION('',(#11277),#11281); +#11277 = LINE('',#11278,#11279); +#11278 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#11279 = VECTOR('',#11280,1.); +#11280 = DIRECTION('',(1.,-1.62688410619E-44)); +#11281 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11282 = FACE_BOUND('',#11283,.T.); +#11283 = EDGE_LOOP('',(#11284,#11309,#11332,#11355,#11378)); +#11284 = ORIENTED_EDGE('',*,*,#11285,.T.); +#11285 = EDGE_CURVE('',#11286,#11288,#11290,.T.); +#11286 = VERTEX_POINT('',#11287); +#11287 = CARTESIAN_POINT('',(4.449999999975,62.599999999996,31.5)); +#11288 = VERTEX_POINT('',#11289); +#11289 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 13.949999999952)); +#11290 = SURFACE_CURVE('',#11291,(#11295,#11302),.PCURVE_S1.); +#11291 = LINE('',#11292,#11293); +#11292 = CARTESIAN_POINT('',(4.149999999975,62.599999999996,31.8)); +#11293 = VECTOR('',#11294,1.); +#11294 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11295 = PCURVE('',#2766,#11296); +#11296 = DEFINITIONAL_REPRESENTATION('',(#11297),#11301); +#11297 = LINE('',#11298,#11299); +#11298 = CARTESIAN_POINT('',(-13.65000000001,26.849999999989)); +#11299 = VECTOR('',#11300,1.); +#11300 = DIRECTION('',(0.707106781187,0.707106781187)); +#11301 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11302 = PCURVE('',#8845,#11303); +#11303 = DEFINITIONAL_REPRESENTATION('',(#11304),#11308); +#11304 = LINE('',#11305,#11306); +#11305 = CARTESIAN_POINT('',(1.712110193826E-15,2.)); +#11306 = VECTOR('',#11307,1.); +#11307 = DIRECTION('',(1.,-4.361251546428E-31)); +#11308 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11309 = ORIENTED_EDGE('',*,*,#11310,.T.); +#11310 = EDGE_CURVE('',#11288,#11311,#11313,.T.); +#11311 = VERTEX_POINT('',#11312); +#11312 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11313 = SURFACE_CURVE('',#11314,(#11318,#11325),.PCURVE_S1.); +#11314 = LINE('',#11315,#11316); +#11315 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,31.5)); +#11316 = VECTOR('',#11317,1.); +#11317 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#11318 = PCURVE('',#2766,#11319); +#11319 = DEFINITIONAL_REPRESENTATION('',(#11320),#11324); +#11320 = LINE('',#11321,#11322); +#11321 = CARTESIAN_POINT('',(-13.35000000001,44.700000000037)); +#11322 = VECTOR('',#11323,1.); +#11323 = DIRECTION('',(1.,-3.996345356033E-31)); +#11324 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11325 = PCURVE('',#8819,#11326); +#11326 = DEFINITIONAL_REPRESENTATION('',(#11327),#11331); +#11327 = LINE('',#11328,#11329); +#11328 = CARTESIAN_POINT('',(3.740318654202E-15,2.)); +#11329 = VECTOR('',#11330,1.); +#11330 = DIRECTION('',(1.,3.944304526105E-31)); +#11331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11332 = ORIENTED_EDGE('',*,*,#11333,.T.); +#11333 = EDGE_CURVE('',#11311,#11334,#11336,.T.); +#11334 = VERTEX_POINT('',#11335); +#11335 = CARTESIAN_POINT('',(21.449999999974,62.599999999996,11.5)); +#11336 = SURFACE_CURVE('',#11337,(#11341,#11348),.PCURVE_S1.); +#11337 = LINE('',#11338,#11339); +#11338 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11339 = VECTOR('',#11340,1.); +#11340 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11341 = PCURVE('',#2766,#11342); +#11342 = DEFINITIONAL_REPRESENTATION('',(#11343),#11347); +#11343 = LINE('',#11344,#11345); +#11344 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11345 = VECTOR('',#11346,1.); +#11346 = DIRECTION('',(0.,-1.)); +#11347 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11348 = PCURVE('',#8791,#11349); +#11349 = DEFINITIONAL_REPRESENTATION('',(#11350),#11354); +#11350 = LINE('',#11351,#11352); +#11351 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11352 = VECTOR('',#11353,1.); +#11353 = DIRECTION('',(1.,1.62688410619E-44)); +#11354 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11355 = ORIENTED_EDGE('',*,*,#11356,.T.); +#11356 = EDGE_CURVE('',#11334,#11357,#11359,.T.); +#11357 = VERTEX_POINT('',#11358); +#11358 = CARTESIAN_POINT('',(1.449999999975,62.599999999996,31.5)); +#11359 = SURFACE_CURVE('',#11360,(#11364,#11371),.PCURVE_S1.); +#11360 = LINE('',#11361,#11362); +#11361 = CARTESIAN_POINT('',(1.149999999975,62.599999999996,31.8)); +#11362 = VECTOR('',#11363,1.); +#11363 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11364 = PCURVE('',#2766,#11365); +#11365 = DEFINITIONAL_REPRESENTATION('',(#11366),#11370); +#11366 = LINE('',#11367,#11368); +#11367 = CARTESIAN_POINT('',(-13.65000000001,23.849999999989)); +#11368 = VECTOR('',#11369,1.); +#11369 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11370 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11371 = PCURVE('',#8763,#11372); +#11372 = DEFINITIONAL_REPRESENTATION('',(#11373),#11377); +#11373 = LINE('',#11374,#11375); +#11374 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11375 = VECTOR('',#11376,1.); +#11376 = DIRECTION('',(1.,3.871099052181E-31)); +#11377 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11378 = ORIENTED_EDGE('',*,*,#11379,.T.); +#11379 = EDGE_CURVE('',#11357,#11286,#11380,.T.); +#11380 = SURFACE_CURVE('',#11381,(#11385,#11392),.PCURVE_S1.); +#11381 = LINE('',#11382,#11383); +#11382 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11383 = VECTOR('',#11384,1.); +#11384 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#11385 = PCURVE('',#2766,#11386); +#11386 = DEFINITIONAL_REPRESENTATION('',(#11387),#11391); +#11387 = LINE('',#11388,#11389); +#11388 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#11389 = VECTOR('',#11390,1.); +#11390 = DIRECTION('',(0.,1.)); +#11391 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11392 = PCURVE('',#8735,#11393); +#11393 = DEFINITIONAL_REPRESENTATION('',(#11394),#11398); +#11394 = LINE('',#11395,#11396); +#11395 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#11396 = VECTOR('',#11397,1.); +#11397 = DIRECTION('',(1.,-1.62688410619E-44)); +#11398 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11399 = FACE_BOUND('',#11400,.T.); +#11400 = EDGE_LOOP('',(#11401,#11426,#11449,#11472)); +#11401 = ORIENTED_EDGE('',*,*,#11402,.T.); +#11402 = EDGE_CURVE('',#11403,#11405,#11407,.T.); +#11403 = VERTEX_POINT('',#11404); +#11404 = CARTESIAN_POINT('',(-13.55000000002,62.599999999996,31.5)); +#11405 = VERTEX_POINT('',#11406); +#11406 = CARTESIAN_POINT('',(6.449999999975,62.599999999996,11.5)); +#11407 = SURFACE_CURVE('',#11408,(#11412,#11419),.PCURVE_S1.); +#11408 = LINE('',#11409,#11410); +#11409 = CARTESIAN_POINT('',(-13.85000000002,62.599999999996,31.8)); +#11410 = VECTOR('',#11411,1.); +#11411 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11412 = PCURVE('',#2766,#11413); +#11413 = DEFINITIONAL_REPRESENTATION('',(#11414),#11418); +#11414 = LINE('',#11415,#11416); +#11415 = CARTESIAN_POINT('',(-13.65000000001,8.849999999989)); +#11416 = VECTOR('',#11417,1.); +#11417 = DIRECTION('',(0.707106781187,0.707106781187)); +#11418 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11419 = PCURVE('',#9643,#11420); +#11420 = DEFINITIONAL_REPRESENTATION('',(#11421),#11425); +#11421 = LINE('',#11422,#11423); +#11422 = CARTESIAN_POINT('',(-8.000377400682E-16,2.)); +#11423 = VECTOR('',#11424,1.); +#11424 = DIRECTION('',(1.,-4.361251546428E-31)); +#11425 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11426 = ORIENTED_EDGE('',*,*,#11427,.T.); +#11427 = EDGE_CURVE('',#11405,#11428,#11430,.T.); +#11428 = VERTEX_POINT('',#11429); +#11429 = CARTESIAN_POINT('',(3.449999999974,62.599999999996,11.5)); +#11430 = SURFACE_CURVE('',#11431,(#11435,#11442),.PCURVE_S1.); +#11431 = LINE('',#11432,#11433); +#11432 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11433 = VECTOR('',#11434,1.); +#11434 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11435 = PCURVE('',#2766,#11436); +#11436 = DEFINITIONAL_REPRESENTATION('',(#11437),#11441); +#11437 = LINE('',#11438,#11439); +#11438 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11439 = VECTOR('',#11440,1.); +#11440 = DIRECTION('',(0.,-1.)); +#11441 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11442 = PCURVE('',#9617,#11443); +#11443 = DEFINITIONAL_REPRESENTATION('',(#11444),#11448); +#11444 = LINE('',#11445,#11446); +#11445 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11446 = VECTOR('',#11447,1.); +#11447 = DIRECTION('',(1.,1.62688410619E-44)); +#11448 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11449 = ORIENTED_EDGE('',*,*,#11450,.T.); +#11450 = EDGE_CURVE('',#11428,#11451,#11453,.T.); +#11451 = VERTEX_POINT('',#11452); +#11452 = CARTESIAN_POINT('',(-16.55000000002,62.599999999996,31.5)); +#11453 = SURFACE_CURVE('',#11454,(#11458,#11465),.PCURVE_S1.); +#11454 = LINE('',#11455,#11456); +#11455 = CARTESIAN_POINT('',(-16.85000000002,62.599999999996,31.8)); +#11456 = VECTOR('',#11457,1.); +#11457 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11458 = PCURVE('',#2766,#11459); +#11459 = DEFINITIONAL_REPRESENTATION('',(#11460),#11464); +#11460 = LINE('',#11461,#11462); +#11461 = CARTESIAN_POINT('',(-13.65000000001,5.849999999989)); +#11462 = VECTOR('',#11463,1.); +#11463 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11464 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11465 = PCURVE('',#9589,#11466); +#11466 = DEFINITIONAL_REPRESENTATION('',(#11467),#11471); +#11467 = LINE('',#11468,#11469); +#11468 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11469 = VECTOR('',#11470,1.); +#11470 = DIRECTION('',(1.,3.871099052181E-31)); +#11471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11472 = ORIENTED_EDGE('',*,*,#11473,.T.); +#11473 = EDGE_CURVE('',#11451,#11403,#11474,.T.); +#11474 = SURFACE_CURVE('',#11475,(#11479,#11486),.PCURVE_S1.); +#11475 = LINE('',#11476,#11477); +#11476 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11477 = VECTOR('',#11478,1.); +#11478 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#11479 = PCURVE('',#2766,#11480); +#11480 = DEFINITIONAL_REPRESENTATION('',(#11481),#11485); +#11481 = LINE('',#11482,#11483); +#11482 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#11483 = VECTOR('',#11484,1.); +#11484 = DIRECTION('',(0.,1.)); +#11485 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11486 = PCURVE('',#9561,#11487); +#11487 = DEFINITIONAL_REPRESENTATION('',(#11488),#11492); +#11488 = LINE('',#11489,#11490); +#11489 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#11490 = VECTOR('',#11491,1.); +#11491 = DIRECTION('',(1.,-1.62688410619E-44)); +#11492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11493 = FACE_BOUND('',#11494,.T.); +#11494 = EDGE_LOOP('',(#11495,#11520,#11543,#11566,#11589)); +#11495 = ORIENTED_EDGE('',*,*,#11496,.T.); +#11496 = EDGE_CURVE('',#11497,#11499,#11501,.T.); +#11497 = VERTEX_POINT('',#11498); +#11498 = CARTESIAN_POINT('',(-25.55000000002,62.599999999996,31.5)); +#11499 = VERTEX_POINT('',#11500); +#11500 = CARTESIAN_POINT('',(-5.550000000025,62.599999999996,11.5)); +#11501 = SURFACE_CURVE('',#11502,(#11506,#11513),.PCURVE_S1.); +#11502 = LINE('',#11503,#11504); +#11503 = CARTESIAN_POINT('',(-25.85000000002,62.599999999996,31.8)); +#11504 = VECTOR('',#11505,1.); +#11505 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11506 = PCURVE('',#2766,#11507); +#11507 = DEFINITIONAL_REPRESENTATION('',(#11508),#11512); +#11508 = LINE('',#11509,#11510); +#11509 = CARTESIAN_POINT('',(-13.65000000001,-3.150000000011)); +#11510 = VECTOR('',#11511,1.); +#11511 = DIRECTION('',(0.707106781187,0.707106781187)); +#11512 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11513 = PCURVE('',#9529,#11514); +#11514 = DEFINITIONAL_REPRESENTATION('',(#11515),#11519); +#11515 = LINE('',#11516,#11517); +#11516 = CARTESIAN_POINT('',(-8.000377400683E-16,2.)); +#11517 = VECTOR('',#11518,1.); +#11518 = DIRECTION('',(1.,-4.361251546428E-31)); +#11519 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11520 = ORIENTED_EDGE('',*,*,#11521,.T.); +#11521 = EDGE_CURVE('',#11499,#11522,#11524,.T.); +#11522 = VERTEX_POINT('',#11523); +#11523 = CARTESIAN_POINT('',(-8.550000000026,62.599999999996,11.5)); +#11524 = SURFACE_CURVE('',#11525,(#11529,#11536),.PCURVE_S1.); +#11525 = LINE('',#11526,#11527); +#11526 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11527 = VECTOR('',#11528,1.); +#11528 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11529 = PCURVE('',#2766,#11530); +#11530 = DEFINITIONAL_REPRESENTATION('',(#11531),#11535); +#11531 = LINE('',#11532,#11533); +#11532 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11533 = VECTOR('',#11534,1.); +#11534 = DIRECTION('',(0.,-1.)); +#11535 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11536 = PCURVE('',#9503,#11537); +#11537 = DEFINITIONAL_REPRESENTATION('',(#11538),#11542); +#11538 = LINE('',#11539,#11540); +#11539 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11540 = VECTOR('',#11541,1.); +#11541 = DIRECTION('',(1.,1.62688410619E-44)); +#11542 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11543 = ORIENTED_EDGE('',*,*,#11544,.T.); +#11544 = EDGE_CURVE('',#11522,#11545,#11547,.T.); +#11545 = VERTEX_POINT('',#11546); +#11546 = CARTESIAN_POINT('',(-26.,62.599999999996,28.949999999979)); +#11547 = SURFACE_CURVE('',#11548,(#11552,#11559),.PCURVE_S1.); +#11548 = LINE('',#11549,#11550); +#11549 = CARTESIAN_POINT('',(-28.85000000002,62.599999999996,31.8)); +#11550 = VECTOR('',#11551,1.); +#11551 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11552 = PCURVE('',#2766,#11553); +#11553 = DEFINITIONAL_REPRESENTATION('',(#11554),#11558); +#11554 = LINE('',#11555,#11556); +#11555 = CARTESIAN_POINT('',(-13.65000000001,-6.150000000011)); +#11556 = VECTOR('',#11557,1.); +#11557 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11559 = PCURVE('',#9475,#11560); +#11560 = DEFINITIONAL_REPRESENTATION('',(#11561),#11565); +#11561 = LINE('',#11562,#11563); +#11562 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11563 = VECTOR('',#11564,1.); +#11564 = DIRECTION('',(1.,3.871099052181E-31)); +#11565 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11566 = ORIENTED_EDGE('',*,*,#11567,.T.); +#11567 = EDGE_CURVE('',#11545,#11568,#11570,.T.); +#11568 = VERTEX_POINT('',#11569); +#11569 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11570 = SURFACE_CURVE('',#11571,(#11575,#11582),.PCURVE_S1.); +#11571 = LINE('',#11572,#11573); +#11572 = CARTESIAN_POINT('',(-26.,62.599999999996,11.5)); +#11573 = VECTOR('',#11574,1.); +#11574 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#11575 = PCURVE('',#2766,#11576); +#11576 = DEFINITIONAL_REPRESENTATION('',(#11577),#11581); +#11577 = LINE('',#11578,#11579); +#11578 = CARTESIAN_POINT('',(6.649999999987,-3.29999999999)); +#11579 = VECTOR('',#11580,1.); +#11580 = DIRECTION('',(-1.,3.996345356033E-31)); +#11581 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11582 = PCURVE('',#9447,#11583); +#11583 = DEFINITIONAL_REPRESENTATION('',(#11584),#11588); +#11584 = LINE('',#11585,#11586); +#11585 = CARTESIAN_POINT('',(-3.740318654202E-15,2.)); +#11586 = VECTOR('',#11587,1.); +#11587 = DIRECTION('',(1.,-3.944304526105E-31)); +#11588 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11589 = ORIENTED_EDGE('',*,*,#11590,.T.); +#11590 = EDGE_CURVE('',#11568,#11497,#11591,.T.); +#11591 = SURFACE_CURVE('',#11592,(#11596,#11603),.PCURVE_S1.); +#11592 = LINE('',#11593,#11594); +#11593 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11594 = VECTOR('',#11595,1.); +#11595 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#11596 = PCURVE('',#2766,#11597); +#11597 = DEFINITIONAL_REPRESENTATION('',(#11598),#11602); +#11598 = LINE('',#11599,#11600); +#11599 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#11600 = VECTOR('',#11601,1.); +#11601 = DIRECTION('',(0.,1.)); +#11602 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11603 = PCURVE('',#9419,#11604); +#11604 = DEFINITIONAL_REPRESENTATION('',(#11605),#11609); +#11605 = LINE('',#11606,#11607); +#11606 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#11607 = VECTOR('',#11608,1.); +#11608 = DIRECTION('',(1.,-1.62688410619E-44)); +#11609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11610 = FACE_BOUND('',#11611,.T.); +#11611 = EDGE_LOOP('',(#11612,#11637,#11660,#11683)); +#11612 = ORIENTED_EDGE('',*,*,#11613,.T.); +#11613 = EDGE_CURVE('',#11614,#11616,#11618,.T.); +#11614 = VERTEX_POINT('',#11615); +#11615 = CARTESIAN_POINT('',(-26.,62.599999999996,25.949999999979)); +#11616 = VERTEX_POINT('',#11617); +#11617 = CARTESIAN_POINT('',(-11.55000000002,62.599999999996,11.5)); +#11618 = SURFACE_CURVE('',#11619,(#11623,#11630),.PCURVE_S1.); +#11619 = LINE('',#11620,#11621); +#11620 = CARTESIAN_POINT('',(-31.85000000002,62.599999999996,31.8)); +#11621 = VECTOR('',#11622,1.); +#11622 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11623 = PCURVE('',#2766,#11624); +#11624 = DEFINITIONAL_REPRESENTATION('',(#11625),#11629); +#11625 = LINE('',#11626,#11627); +#11626 = CARTESIAN_POINT('',(-13.65000000001,-9.150000000011)); +#11627 = VECTOR('',#11628,1.); +#11628 = DIRECTION('',(0.707106781187,0.707106781187)); +#11629 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11630 = PCURVE('',#9187,#11631); +#11631 = DEFINITIONAL_REPRESENTATION('',(#11632),#11636); +#11632 = LINE('',#11633,#11634); +#11633 = CARTESIAN_POINT('',(4.560362268789E-16,2.)); +#11634 = VECTOR('',#11635,1.); +#11635 = DIRECTION('',(1.,-4.361251546428E-31)); +#11636 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11637 = ORIENTED_EDGE('',*,*,#11638,.T.); +#11638 = EDGE_CURVE('',#11616,#11639,#11641,.T.); +#11639 = VERTEX_POINT('',#11640); +#11640 = CARTESIAN_POINT('',(-14.55000000002,62.599999999996,11.5)); +#11641 = SURFACE_CURVE('',#11642,(#11646,#11653),.PCURVE_S1.); +#11642 = LINE('',#11643,#11644); +#11643 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11644 = VECTOR('',#11645,1.); +#11645 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11646 = PCURVE('',#2766,#11647); +#11647 = DEFINITIONAL_REPRESENTATION('',(#11648),#11652); +#11648 = LINE('',#11649,#11650); +#11649 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11650 = VECTOR('',#11651,1.); +#11651 = DIRECTION('',(0.,-1.)); +#11652 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11653 = PCURVE('',#9161,#11654); +#11654 = DEFINITIONAL_REPRESENTATION('',(#11655),#11659); +#11655 = LINE('',#11656,#11657); +#11656 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11657 = VECTOR('',#11658,1.); +#11658 = DIRECTION('',(1.,1.62688410619E-44)); +#11659 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11660 = ORIENTED_EDGE('',*,*,#11661,.T.); +#11661 = EDGE_CURVE('',#11639,#11662,#11664,.T.); +#11662 = VERTEX_POINT('',#11663); +#11663 = CARTESIAN_POINT('',(-26.,62.599999999996,22.949999999979)); +#11664 = SURFACE_CURVE('',#11665,(#11669,#11676),.PCURVE_S1.); +#11665 = LINE('',#11666,#11667); +#11666 = CARTESIAN_POINT('',(-34.85000000002,62.599999999996,31.8)); +#11667 = VECTOR('',#11668,1.); +#11668 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11669 = PCURVE('',#2766,#11670); +#11670 = DEFINITIONAL_REPRESENTATION('',(#11671),#11675); +#11671 = LINE('',#11672,#11673); +#11672 = CARTESIAN_POINT('',(-13.65000000001,-12.15000000001)); +#11673 = VECTOR('',#11674,1.); +#11674 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11675 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11676 = PCURVE('',#9133,#11677); +#11677 = DEFINITIONAL_REPRESENTATION('',(#11678),#11682); +#11678 = LINE('',#11679,#11680); +#11679 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11680 = VECTOR('',#11681,1.); +#11681 = DIRECTION('',(1.,3.871099052181E-31)); +#11682 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11683 = ORIENTED_EDGE('',*,*,#11684,.T.); +#11684 = EDGE_CURVE('',#11662,#11614,#11685,.T.); +#11685 = SURFACE_CURVE('',#11686,(#11690,#11697),.PCURVE_S1.); +#11686 = LINE('',#11687,#11688); +#11687 = CARTESIAN_POINT('',(-26.,62.599999999996,11.5)); +#11688 = VECTOR('',#11689,1.); +#11689 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#11690 = PCURVE('',#2766,#11691); +#11691 = DEFINITIONAL_REPRESENTATION('',(#11692),#11696); +#11692 = LINE('',#11693,#11694); +#11693 = CARTESIAN_POINT('',(6.649999999987,-3.29999999999)); +#11694 = VECTOR('',#11695,1.); +#11695 = DIRECTION('',(-1.,3.996345356033E-31)); +#11696 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11697 = PCURVE('',#9105,#11698); +#11698 = DEFINITIONAL_REPRESENTATION('',(#11699),#11703); +#11699 = LINE('',#11700,#11701); +#11700 = CARTESIAN_POINT('',(-3.740318654202E-15,2.)); +#11701 = VECTOR('',#11702,1.); +#11702 = DIRECTION('',(1.,-3.944304526105E-31)); +#11703 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11704 = FACE_BOUND('',#11705,.T.); +#11705 = EDGE_LOOP('',(#11706,#11731,#11754)); +#11706 = ORIENTED_EDGE('',*,*,#11707,.T.); +#11707 = EDGE_CURVE('',#11708,#11710,#11712,.T.); +#11708 = VERTEX_POINT('',#11709); +#11709 = CARTESIAN_POINT('',(-26.,62.599999999996,13.949999999979)); +#11710 = VERTEX_POINT('',#11711); +#11711 = CARTESIAN_POINT('',(-23.55000000002,62.599999999996,11.5)); +#11712 = SURFACE_CURVE('',#11713,(#11717,#11724),.PCURVE_S1.); +#11713 = LINE('',#11714,#11715); +#11714 = CARTESIAN_POINT('',(-43.85000000002,62.599999999996,31.8)); +#11715 = VECTOR('',#11716,1.); +#11716 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11717 = PCURVE('',#2766,#11718); +#11718 = DEFINITIONAL_REPRESENTATION('',(#11719),#11723); +#11719 = LINE('',#11720,#11721); +#11720 = CARTESIAN_POINT('',(-13.65000000001,-21.15000000001)); +#11721 = VECTOR('',#11722,1.); +#11722 = DIRECTION('',(0.707106781187,0.707106781187)); +#11723 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11724 = PCURVE('',#9273,#11725); +#11725 = DEFINITIONAL_REPRESENTATION('',(#11726),#11730); +#11726 = LINE('',#11727,#11728); +#11727 = CARTESIAN_POINT('',(3.439211898378E-15,2.)); +#11728 = VECTOR('',#11729,1.); +#11729 = DIRECTION('',(1.,-4.361251546428E-31)); +#11730 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11731 = ORIENTED_EDGE('',*,*,#11732,.T.); +#11732 = EDGE_CURVE('',#11710,#11733,#11735,.T.); +#11733 = VERTEX_POINT('',#11734); +#11734 = CARTESIAN_POINT('',(-26.,62.599999999996,11.5)); +#11735 = SURFACE_CURVE('',#11736,(#11740,#11747),.PCURVE_S1.); +#11736 = LINE('',#11737,#11738); +#11737 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11738 = VECTOR('',#11739,1.); +#11739 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11740 = PCURVE('',#2766,#11741); +#11741 = DEFINITIONAL_REPRESENTATION('',(#11742),#11746); +#11742 = LINE('',#11743,#11744); +#11743 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11744 = VECTOR('',#11745,1.); +#11745 = DIRECTION('',(0.,-1.)); +#11746 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11747 = PCURVE('',#9247,#11748); +#11748 = DEFINITIONAL_REPRESENTATION('',(#11749),#11753); +#11749 = LINE('',#11750,#11751); +#11750 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11751 = VECTOR('',#11752,1.); +#11752 = DIRECTION('',(1.,1.62688410619E-44)); +#11753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11754 = ORIENTED_EDGE('',*,*,#11755,.T.); +#11755 = EDGE_CURVE('',#11733,#11708,#11756,.T.); +#11756 = SURFACE_CURVE('',#11757,(#11761,#11768),.PCURVE_S1.); +#11757 = LINE('',#11758,#11759); +#11758 = CARTESIAN_POINT('',(-26.,62.599999999996,11.5)); +#11759 = VECTOR('',#11760,1.); +#11760 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#11761 = PCURVE('',#2766,#11762); +#11762 = DEFINITIONAL_REPRESENTATION('',(#11763),#11767); +#11763 = LINE('',#11764,#11765); +#11764 = CARTESIAN_POINT('',(6.649999999987,-3.29999999999)); +#11765 = VECTOR('',#11766,1.); +#11766 = DIRECTION('',(-1.,3.996345356033E-31)); +#11767 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11768 = PCURVE('',#9219,#11769); +#11769 = DEFINITIONAL_REPRESENTATION('',(#11770),#11774); +#11770 = LINE('',#11771,#11772); +#11771 = CARTESIAN_POINT('',(-3.740318654202E-15,2.)); +#11772 = VECTOR('',#11773,1.); +#11773 = DIRECTION('',(1.,-3.944304526105E-31)); +#11774 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11775 = FACE_BOUND('',#11776,.T.); +#11776 = EDGE_LOOP('',(#11777,#11802,#11825,#11848)); +#11777 = ORIENTED_EDGE('',*,*,#11778,.T.); +#11778 = EDGE_CURVE('',#11779,#11781,#11783,.T.); +#11779 = VERTEX_POINT('',#11780); +#11780 = CARTESIAN_POINT('',(-26.,62.599999999996,19.949999999979)); +#11781 = VERTEX_POINT('',#11782); +#11782 = CARTESIAN_POINT('',(-17.55000000002,62.599999999996,11.5)); +#11783 = SURFACE_CURVE('',#11784,(#11788,#11795),.PCURVE_S1.); +#11784 = LINE('',#11785,#11786); +#11785 = CARTESIAN_POINT('',(-37.85000000002,62.599999999996,31.8)); +#11786 = VECTOR('',#11787,1.); +#11787 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11788 = PCURVE('',#2766,#11789); +#11789 = DEFINITIONAL_REPRESENTATION('',(#11790),#11794); +#11790 = LINE('',#11791,#11792); +#11791 = CARTESIAN_POINT('',(-13.65000000001,-15.15000000001)); +#11792 = VECTOR('',#11793,1.); +#11793 = DIRECTION('',(0.707106781187,0.707106781187)); +#11794 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11795 = PCURVE('',#9387,#11796); +#11796 = DEFINITIONAL_REPRESENTATION('',(#11797),#11801); +#11797 = LINE('',#11798,#11799); +#11798 = CARTESIAN_POINT('',(3.596221144246E-15,2.)); +#11799 = VECTOR('',#11800,1.); +#11800 = DIRECTION('',(1.,-4.361251546428E-31)); +#11801 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11802 = ORIENTED_EDGE('',*,*,#11803,.T.); +#11803 = EDGE_CURVE('',#11781,#11804,#11806,.T.); +#11804 = VERTEX_POINT('',#11805); +#11805 = CARTESIAN_POINT('',(-20.55000000002,62.599999999996,11.5)); +#11806 = SURFACE_CURVE('',#11807,(#11811,#11818),.PCURVE_S1.); +#11807 = LINE('',#11808,#11809); +#11808 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11809 = VECTOR('',#11810,1.); +#11810 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11811 = PCURVE('',#2766,#11812); +#11812 = DEFINITIONAL_REPRESENTATION('',(#11813),#11817); +#11813 = LINE('',#11814,#11815); +#11814 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11815 = VECTOR('',#11816,1.); +#11816 = DIRECTION('',(0.,-1.)); +#11817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11818 = PCURVE('',#9361,#11819); +#11819 = DEFINITIONAL_REPRESENTATION('',(#11820),#11824); +#11820 = LINE('',#11821,#11822); +#11821 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11822 = VECTOR('',#11823,1.); +#11823 = DIRECTION('',(1.,1.62688410619E-44)); +#11824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11825 = ORIENTED_EDGE('',*,*,#11826,.T.); +#11826 = EDGE_CURVE('',#11804,#11827,#11829,.T.); +#11827 = VERTEX_POINT('',#11828); +#11828 = CARTESIAN_POINT('',(-26.,62.599999999996,16.949999999979)); +#11829 = SURFACE_CURVE('',#11830,(#11834,#11841),.PCURVE_S1.); +#11830 = LINE('',#11831,#11832); +#11831 = CARTESIAN_POINT('',(-40.85000000002,62.599999999996,31.8)); +#11832 = VECTOR('',#11833,1.); +#11833 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11834 = PCURVE('',#2766,#11835); +#11835 = DEFINITIONAL_REPRESENTATION('',(#11836),#11840); +#11836 = LINE('',#11837,#11838); +#11837 = CARTESIAN_POINT('',(-13.65000000001,-18.15000000001)); +#11838 = VECTOR('',#11839,1.); +#11839 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11840 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11841 = PCURVE('',#9333,#11842); +#11842 = DEFINITIONAL_REPRESENTATION('',(#11843),#11847); +#11843 = LINE('',#11844,#11845); +#11844 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11845 = VECTOR('',#11846,1.); +#11846 = DIRECTION('',(1.,3.871099052181E-31)); +#11847 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11848 = ORIENTED_EDGE('',*,*,#11849,.T.); +#11849 = EDGE_CURVE('',#11827,#11779,#11850,.T.); +#11850 = SURFACE_CURVE('',#11851,(#11855,#11862),.PCURVE_S1.); +#11851 = LINE('',#11852,#11853); +#11852 = CARTESIAN_POINT('',(-26.,62.599999999996,11.5)); +#11853 = VECTOR('',#11854,1.); +#11854 = DIRECTION('',(5.88029709377E-29,1.870159327101E-15,1.)); +#11855 = PCURVE('',#2766,#11856); +#11856 = DEFINITIONAL_REPRESENTATION('',(#11857),#11861); +#11857 = LINE('',#11858,#11859); +#11858 = CARTESIAN_POINT('',(6.649999999987,-3.29999999999)); +#11859 = VECTOR('',#11860,1.); +#11860 = DIRECTION('',(-1.,3.996345356033E-31)); +#11861 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11862 = PCURVE('',#9305,#11863); +#11863 = DEFINITIONAL_REPRESENTATION('',(#11864),#11868); +#11864 = LINE('',#11865,#11866); +#11865 = CARTESIAN_POINT('',(-3.740318654202E-15,2.)); +#11866 = VECTOR('',#11867,1.); +#11867 = DIRECTION('',(1.,-3.944304526105E-31)); +#11868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11869 = FACE_BOUND('',#11870,.T.); +#11870 = EDGE_LOOP('',(#11871,#11896,#11919,#11942)); +#11871 = ORIENTED_EDGE('',*,*,#11872,.T.); +#11872 = EDGE_CURVE('',#11873,#11875,#11877,.T.); +#11873 = VERTEX_POINT('',#11874); +#11874 = CARTESIAN_POINT('',(-19.55000000002,62.599999999996,31.5)); +#11875 = VERTEX_POINT('',#11876); +#11876 = CARTESIAN_POINT('',(0.449999999975,62.599999999996,11.5)); +#11877 = SURFACE_CURVE('',#11878,(#11882,#11889),.PCURVE_S1.); +#11878 = LINE('',#11879,#11880); +#11879 = CARTESIAN_POINT('',(-19.85000000002,62.599999999996,31.8)); +#11880 = VECTOR('',#11881,1.); +#11881 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11882 = PCURVE('',#2766,#11883); +#11883 = DEFINITIONAL_REPRESENTATION('',(#11884),#11888); +#11884 = LINE('',#11885,#11886); +#11885 = CARTESIAN_POINT('',(-13.65000000001,2.849999999989)); +#11886 = VECTOR('',#11887,1.); +#11887 = DIRECTION('',(0.707106781187,0.707106781187)); +#11888 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11889 = PCURVE('',#9073,#11890); +#11890 = DEFINITIONAL_REPRESENTATION('',(#11891),#11895); +#11891 = LINE('',#11892,#11893); +#11892 = CARTESIAN_POINT('',(-8.000377400682E-16,2.)); +#11893 = VECTOR('',#11894,1.); +#11894 = DIRECTION('',(1.,-4.361251546428E-31)); +#11895 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11896 = ORIENTED_EDGE('',*,*,#11897,.T.); +#11897 = EDGE_CURVE('',#11875,#11898,#11900,.T.); +#11898 = VERTEX_POINT('',#11899); +#11899 = CARTESIAN_POINT('',(-2.550000000026,62.599999999996,11.5)); +#11900 = SURFACE_CURVE('',#11901,(#11905,#11912),.PCURVE_S1.); +#11901 = LINE('',#11902,#11903); +#11902 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11903 = VECTOR('',#11904,1.); +#11904 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11905 = PCURVE('',#2766,#11906); +#11906 = DEFINITIONAL_REPRESENTATION('',(#11907),#11911); +#11907 = LINE('',#11908,#11909); +#11908 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#11909 = VECTOR('',#11910,1.); +#11910 = DIRECTION('',(0.,-1.)); +#11911 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11912 = PCURVE('',#9047,#11913); +#11913 = DEFINITIONAL_REPRESENTATION('',(#11914),#11918); +#11914 = LINE('',#11915,#11916); +#11915 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#11916 = VECTOR('',#11917,1.); +#11917 = DIRECTION('',(1.,1.62688410619E-44)); +#11918 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11919 = ORIENTED_EDGE('',*,*,#11920,.T.); +#11920 = EDGE_CURVE('',#11898,#11921,#11923,.T.); +#11921 = VERTEX_POINT('',#11922); +#11922 = CARTESIAN_POINT('',(-22.55000000002,62.599999999996,31.5)); +#11923 = SURFACE_CURVE('',#11924,(#11928,#11935),.PCURVE_S1.); +#11924 = LINE('',#11925,#11926); +#11925 = CARTESIAN_POINT('',(-22.85000000002,62.599999999996,31.8)); +#11926 = VECTOR('',#11927,1.); +#11927 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#11928 = PCURVE('',#2766,#11929); +#11929 = DEFINITIONAL_REPRESENTATION('',(#11930),#11934); +#11930 = LINE('',#11931,#11932); +#11931 = CARTESIAN_POINT('',(-13.65000000001,-0.150000000011)); +#11932 = VECTOR('',#11933,1.); +#11933 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#11934 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11935 = PCURVE('',#9019,#11936); +#11936 = DEFINITIONAL_REPRESENTATION('',(#11937),#11941); +#11937 = LINE('',#11938,#11939); +#11938 = CARTESIAN_POINT('',(35.779603128055,2.)); +#11939 = VECTOR('',#11940,1.); +#11940 = DIRECTION('',(1.,3.871099052181E-31)); +#11941 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11942 = ORIENTED_EDGE('',*,*,#11943,.T.); +#11943 = EDGE_CURVE('',#11921,#11873,#11944,.T.); +#11944 = SURFACE_CURVE('',#11945,(#11949,#11956),.PCURVE_S1.); +#11945 = LINE('',#11946,#11947); +#11946 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#11947 = VECTOR('',#11948,1.); +#11948 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#11949 = PCURVE('',#2766,#11950); +#11950 = DEFINITIONAL_REPRESENTATION('',(#11951),#11955); +#11951 = LINE('',#11952,#11953); +#11952 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#11953 = VECTOR('',#11954,1.); +#11954 = DIRECTION('',(0.,1.)); +#11955 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11956 = PCURVE('',#8991,#11957); +#11957 = DEFINITIONAL_REPRESENTATION('',(#11958),#11962); +#11958 = LINE('',#11959,#11960); +#11959 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#11960 = VECTOR('',#11961,1.); +#11961 = DIRECTION('',(1.,-1.62688410619E-44)); +#11962 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11963 = FACE_BOUND('',#11964,.T.); +#11964 = EDGE_LOOP('',(#11965,#11990,#12013,#12036)); +#11965 = ORIENTED_EDGE('',*,*,#11966,.T.); +#11966 = EDGE_CURVE('',#11967,#11969,#11971,.T.); +#11967 = VERTEX_POINT('',#11968); +#11968 = CARTESIAN_POINT('',(-7.550000000025,62.599999999996,31.5)); +#11969 = VERTEX_POINT('',#11970); +#11970 = CARTESIAN_POINT('',(12.449999999975,62.599999999996,11.5)); +#11971 = SURFACE_CURVE('',#11972,(#11976,#11983),.PCURVE_S1.); +#11972 = LINE('',#11973,#11974); +#11973 = CARTESIAN_POINT('',(-7.850000000025,62.599999999996,31.8)); +#11974 = VECTOR('',#11975,1.); +#11975 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#11976 = PCURVE('',#2766,#11977); +#11977 = DEFINITIONAL_REPRESENTATION('',(#11978),#11982); +#11978 = LINE('',#11979,#11980); +#11979 = CARTESIAN_POINT('',(-13.65000000001,14.849999999989)); +#11980 = VECTOR('',#11981,1.); +#11981 = DIRECTION('',(0.707106781187,0.707106781187)); +#11982 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11983 = PCURVE('',#8959,#11984); +#11984 = DEFINITIONAL_REPRESENTATION('',(#11985),#11989); +#11985 = LINE('',#11986,#11987); +#11986 = CARTESIAN_POINT('',(1.712110193826E-15,2.)); +#11987 = VECTOR('',#11988,1.); +#11988 = DIRECTION('',(1.,-4.361251546428E-31)); +#11989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#11990 = ORIENTED_EDGE('',*,*,#11991,.T.); +#11991 = EDGE_CURVE('',#11969,#11992,#11994,.T.); +#11992 = VERTEX_POINT('',#11993); +#11993 = CARTESIAN_POINT('',(9.449999999974,62.599999999996,11.5)); +#11994 = SURFACE_CURVE('',#11995,(#11999,#12006),.PCURVE_S1.); +#11995 = LINE('',#11996,#11997); +#11996 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#11997 = VECTOR('',#11998,1.); +#11998 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#11999 = PCURVE('',#2766,#12000); +#12000 = DEFINITIONAL_REPRESENTATION('',(#12001),#12005); +#12001 = LINE('',#12002,#12003); +#12002 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#12003 = VECTOR('',#12004,1.); +#12004 = DIRECTION('',(0.,-1.)); +#12005 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12006 = PCURVE('',#8933,#12007); +#12007 = DEFINITIONAL_REPRESENTATION('',(#12008),#12012); +#12008 = LINE('',#12009,#12010); +#12009 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#12010 = VECTOR('',#12011,1.); +#12011 = DIRECTION('',(1.,1.62688410619E-44)); +#12012 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12013 = ORIENTED_EDGE('',*,*,#12014,.T.); +#12014 = EDGE_CURVE('',#11992,#12015,#12017,.T.); +#12015 = VERTEX_POINT('',#12016); +#12016 = CARTESIAN_POINT('',(-10.55000000002,62.599999999996,31.5)); +#12017 = SURFACE_CURVE('',#12018,(#12022,#12029),.PCURVE_S1.); +#12018 = LINE('',#12019,#12020); +#12019 = CARTESIAN_POINT('',(-10.85000000002,62.599999999996,31.8)); +#12020 = VECTOR('',#12021,1.); +#12021 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#12022 = PCURVE('',#2766,#12023); +#12023 = DEFINITIONAL_REPRESENTATION('',(#12024),#12028); +#12024 = LINE('',#12025,#12026); +#12025 = CARTESIAN_POINT('',(-13.65000000001,11.849999999989)); +#12026 = VECTOR('',#12027,1.); +#12027 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12028 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12029 = PCURVE('',#8905,#12030); +#12030 = DEFINITIONAL_REPRESENTATION('',(#12031),#12035); +#12031 = LINE('',#12032,#12033); +#12032 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12033 = VECTOR('',#12034,1.); +#12034 = DIRECTION('',(1.,3.871099052181E-31)); +#12035 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12036 = ORIENTED_EDGE('',*,*,#12037,.T.); +#12037 = EDGE_CURVE('',#12015,#11967,#12038,.T.); +#12038 = SURFACE_CURVE('',#12039,(#12043,#12050),.PCURVE_S1.); +#12039 = LINE('',#12040,#12041); +#12040 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#12041 = VECTOR('',#12042,1.); +#12042 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#12043 = PCURVE('',#2766,#12044); +#12044 = DEFINITIONAL_REPRESENTATION('',(#12045),#12049); +#12045 = LINE('',#12046,#12047); +#12046 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#12047 = VECTOR('',#12048,1.); +#12048 = DIRECTION('',(0.,1.)); +#12049 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12050 = PCURVE('',#8877,#12051); +#12051 = DEFINITIONAL_REPRESENTATION('',(#12052),#12056); +#12052 = LINE('',#12053,#12054); +#12053 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#12054 = VECTOR('',#12055,1.); +#12055 = DIRECTION('',(1.,-1.62688410619E-44)); +#12056 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12057 = FACE_BOUND('',#12058,.T.); +#12058 = EDGE_LOOP('',(#12059,#12084,#12107,#12130)); +#12059 = ORIENTED_EDGE('',*,*,#12060,.T.); +#12060 = EDGE_CURVE('',#12061,#12063,#12065,.T.); +#12061 = VERTEX_POINT('',#12062); +#12062 = CARTESIAN_POINT('',(-1.550000000025,62.599999999996,31.5)); +#12063 = VERTEX_POINT('',#12064); +#12064 = CARTESIAN_POINT('',(18.449999999975,62.599999999996,11.5)); +#12065 = SURFACE_CURVE('',#12066,(#12070,#12077),.PCURVE_S1.); +#12066 = LINE('',#12067,#12068); +#12067 = CARTESIAN_POINT('',(-1.850000000025,62.599999999996,31.8)); +#12068 = VECTOR('',#12069,1.); +#12069 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#12070 = PCURVE('',#2766,#12071); +#12071 = DEFINITIONAL_REPRESENTATION('',(#12072),#12076); +#12072 = LINE('',#12073,#12074); +#12073 = CARTESIAN_POINT('',(-13.65000000001,20.849999999989)); +#12074 = VECTOR('',#12075,1.); +#12075 = DIRECTION('',(0.707106781187,0.707106781187)); +#12076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12077 = PCURVE('',#9757,#12078); +#12078 = DEFINITIONAL_REPRESENTATION('',(#12079),#12083); +#12079 = LINE('',#12080,#12081); +#12080 = CARTESIAN_POINT('',(1.712110193826E-15,2.)); +#12081 = VECTOR('',#12082,1.); +#12082 = DIRECTION('',(1.,2.050733463254E-31)); +#12083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12084 = ORIENTED_EDGE('',*,*,#12085,.T.); +#12085 = EDGE_CURVE('',#12063,#12086,#12088,.T.); +#12086 = VERTEX_POINT('',#12087); +#12087 = CARTESIAN_POINT('',(15.449999999974,62.599999999996,11.5)); +#12088 = SURFACE_CURVE('',#12089,(#12093,#12100),.PCURVE_S1.); +#12089 = LINE('',#12090,#12091); +#12090 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,11.5)); +#12091 = VECTOR('',#12092,1.); +#12092 = DIRECTION('',(-1.,-4.212228277709E-15,6.668050893914E-29)); +#12093 = PCURVE('',#2766,#12094); +#12094 = DEFINITIONAL_REPRESENTATION('',(#12095),#12099); +#12095 = LINE('',#12096,#12097); +#12096 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#12097 = VECTOR('',#12098,1.); +#12098 = DIRECTION('',(0.,-1.)); +#12099 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12100 = PCURVE('',#9731,#12101); +#12101 = DEFINITIONAL_REPRESENTATION('',(#12102),#12106); +#12102 = LINE('',#12103,#12104); +#12103 = CARTESIAN_POINT('',(8.424456555417E-15,2.)); +#12104 = VECTOR('',#12105,1.); +#12105 = DIRECTION('',(1.,1.62688410619E-44)); +#12106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12107 = ORIENTED_EDGE('',*,*,#12108,.T.); +#12108 = EDGE_CURVE('',#12086,#12109,#12111,.T.); +#12109 = VERTEX_POINT('',#12110); +#12110 = CARTESIAN_POINT('',(-4.550000000025,62.599999999996,31.5)); +#12111 = SURFACE_CURVE('',#12112,(#12116,#12123),.PCURVE_S1.); +#12112 = LINE('',#12113,#12114); +#12113 = CARTESIAN_POINT('',(-4.850000000025,62.599999999996,31.8)); +#12114 = VECTOR('',#12115,1.); +#12115 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#12116 = PCURVE('',#2766,#12117); +#12117 = DEFINITIONAL_REPRESENTATION('',(#12118),#12122); +#12118 = LINE('',#12119,#12120); +#12119 = CARTESIAN_POINT('',(-13.65000000001,17.849999999989)); +#12120 = VECTOR('',#12121,1.); +#12121 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12122 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12123 = PCURVE('',#9703,#12124); +#12124 = DEFINITIONAL_REPRESENTATION('',(#12125),#12129); +#12125 = LINE('',#12126,#12127); +#12126 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12127 = VECTOR('',#12128,1.); +#12128 = DIRECTION('',(1.,3.871099052181E-31)); +#12129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12130 = ORIENTED_EDGE('',*,*,#12131,.T.); +#12131 = EDGE_CURVE('',#12109,#12061,#12132,.T.); +#12132 = SURFACE_CURVE('',#12133,(#12137,#12144),.PCURVE_S1.); +#12133 = LINE('',#12134,#12135); +#12134 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#12135 = VECTOR('',#12136,1.); +#12136 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#12137 = PCURVE('',#2766,#12138); +#12138 = DEFINITIONAL_REPRESENTATION('',(#12139),#12143); +#12139 = LINE('',#12140,#12141); +#12140 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#12141 = VECTOR('',#12142,1.); +#12142 = DIRECTION('',(0.,1.)); +#12143 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12144 = PCURVE('',#9675,#12145); +#12145 = DEFINITIONAL_REPRESENTATION('',(#12146),#12150); +#12146 = LINE('',#12147,#12148); +#12147 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#12148 = VECTOR('',#12149,1.); +#12149 = DIRECTION('',(1.,-1.62688410619E-44)); +#12150 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12151 = FACE_BOUND('',#12152,.T.); +#12152 = EDGE_LOOP('',(#12153,#12178,#12201,#12224)); +#12153 = ORIENTED_EDGE('',*,*,#12154,.T.); +#12154 = EDGE_CURVE('',#12155,#12157,#12159,.T.); +#12155 = VERTEX_POINT('',#12156); +#12156 = CARTESIAN_POINT('',(10.449999999975,62.599999999996,31.5)); +#12157 = VERTEX_POINT('',#12158); +#12158 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 19.949999999952)); +#12159 = SURFACE_CURVE('',#12160,(#12164,#12171),.PCURVE_S1.); +#12160 = LINE('',#12161,#12162); +#12161 = CARTESIAN_POINT('',(10.149999999975,62.599999999996,31.8)); +#12162 = VECTOR('',#12163,1.); +#12163 = DIRECTION('',(0.707106781187,1.656092836981E-15,-0.707106781187 + )); +#12164 = PCURVE('',#2766,#12165); +#12165 = DEFINITIONAL_REPRESENTATION('',(#12166),#12170); +#12166 = LINE('',#12167,#12168); +#12167 = CARTESIAN_POINT('',(-13.65000000001,32.849999999989)); +#12168 = VECTOR('',#12169,1.); +#12169 = DIRECTION('',(0.707106781187,0.707106781187)); +#12170 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12171 = PCURVE('',#9871,#12172); +#12172 = DEFINITIONAL_REPRESENTATION('',(#12173),#12177); +#12173 = LINE('',#12174,#12175); +#12174 = CARTESIAN_POINT('',(1.712110193826E-15,2.)); +#12175 = VECTOR('',#12176,1.); +#12176 = DIRECTION('',(1.,-4.361251546428E-31)); +#12177 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12178 = ORIENTED_EDGE('',*,*,#12179,.T.); +#12179 = EDGE_CURVE('',#12157,#12180,#12182,.T.); +#12180 = VERTEX_POINT('',#12181); +#12181 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 16.949999999951)); +#12182 = SURFACE_CURVE('',#12183,(#12187,#12194),.PCURVE_S1.); +#12183 = LINE('',#12184,#12185); +#12184 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,31.5)); +#12185 = VECTOR('',#12186,1.); +#12186 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#12187 = PCURVE('',#2766,#12188); +#12188 = DEFINITIONAL_REPRESENTATION('',(#12189),#12193); +#12189 = LINE('',#12190,#12191); +#12190 = CARTESIAN_POINT('',(-13.35000000001,44.700000000037)); +#12191 = VECTOR('',#12192,1.); +#12192 = DIRECTION('',(1.,-3.996345356033E-31)); +#12193 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12194 = PCURVE('',#9845,#12195); +#12195 = DEFINITIONAL_REPRESENTATION('',(#12196),#12200); +#12196 = LINE('',#12197,#12198); +#12197 = CARTESIAN_POINT('',(3.740318654202E-15,2.)); +#12198 = VECTOR('',#12199,1.); +#12199 = DIRECTION('',(1.,3.944304526105E-31)); +#12200 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12201 = ORIENTED_EDGE('',*,*,#12202,.T.); +#12202 = EDGE_CURVE('',#12180,#12203,#12205,.T.); +#12203 = VERTEX_POINT('',#12204); +#12204 = CARTESIAN_POINT('',(7.449999999975,62.599999999996,31.5)); +#12205 = SURFACE_CURVE('',#12206,(#12210,#12217),.PCURVE_S1.); +#12206 = LINE('',#12207,#12208); +#12207 = CARTESIAN_POINT('',(7.149999999975,62.599999999996,31.8)); +#12208 = VECTOR('',#12209,1.); +#12209 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#12210 = PCURVE('',#2766,#12211); +#12211 = DEFINITIONAL_REPRESENTATION('',(#12212),#12216); +#12212 = LINE('',#12213,#12214); +#12213 = CARTESIAN_POINT('',(-13.65000000001,29.849999999989)); +#12214 = VECTOR('',#12215,1.); +#12215 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12217 = PCURVE('',#9817,#12218); +#12218 = DEFINITIONAL_REPRESENTATION('',(#12219),#12223); +#12219 = LINE('',#12220,#12221); +#12220 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12221 = VECTOR('',#12222,1.); +#12222 = DIRECTION('',(1.,3.871099052181E-31)); +#12223 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12224 = ORIENTED_EDGE('',*,*,#12225,.T.); +#12225 = EDGE_CURVE('',#12203,#12155,#12226,.T.); +#12226 = SURFACE_CURVE('',#12227,(#12231,#12238),.PCURVE_S1.); +#12227 = LINE('',#12228,#12229); +#12228 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#12229 = VECTOR('',#12230,1.); +#12230 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#12231 = PCURVE('',#2766,#12232); +#12232 = DEFINITIONAL_REPRESENTATION('',(#12233),#12237); +#12233 = LINE('',#12234,#12235); +#12234 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#12235 = VECTOR('',#12236,1.); +#12236 = DIRECTION('',(0.,1.)); +#12237 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12238 = PCURVE('',#9789,#12239); +#12239 = DEFINITIONAL_REPRESENTATION('',(#12240),#12244); +#12240 = LINE('',#12241,#12242); +#12241 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#12242 = VECTOR('',#12243,1.); +#12243 = DIRECTION('',(1.,-1.62688410619E-44)); +#12244 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12245 = FACE_BOUND('',#12246,.T.); +#12246 = EDGE_LOOP('',(#12247,#12272,#12295)); +#12247 = ORIENTED_EDGE('',*,*,#12248,.T.); +#12248 = EDGE_CURVE('',#12249,#12251,#12253,.T.); +#12249 = VERTEX_POINT('',#12250); +#12250 = CARTESIAN_POINT('',(19.449999999975,62.599999999996,31.5)); +#12251 = VERTEX_POINT('',#12252); +#12252 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,31.5)); +#12253 = SURFACE_CURVE('',#12254,(#12258,#12265),.PCURVE_S1.); +#12254 = LINE('',#12255,#12256); +#12255 = CARTESIAN_POINT('',(-26.,62.599999999996,31.5)); +#12256 = VECTOR('',#12257,1.); +#12257 = DIRECTION('',(1.,4.212228277709E-15,-6.668050893914E-29)); +#12258 = PCURVE('',#2766,#12259); +#12259 = DEFINITIONAL_REPRESENTATION('',(#12260),#12264); +#12260 = LINE('',#12261,#12262); +#12261 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#12262 = VECTOR('',#12263,1.); +#12263 = DIRECTION('',(0.,1.)); +#12264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12265 = PCURVE('',#9957,#12266); +#12266 = DEFINITIONAL_REPRESENTATION('',(#12267),#12271); +#12267 = LINE('',#12268,#12269); +#12268 = CARTESIAN_POINT('',(-8.424456555418E-15,2.)); +#12269 = VECTOR('',#12270,1.); +#12270 = DIRECTION('',(1.,-1.62688410619E-44)); +#12271 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12272 = ORIENTED_EDGE('',*,*,#12273,.T.); +#12273 = EDGE_CURVE('',#12251,#12274,#12276,.T.); +#12274 = VERTEX_POINT('',#12275); +#12275 = CARTESIAN_POINT('',(22.000000000023,62.599999999996, + 28.949999999951)); +#12276 = SURFACE_CURVE('',#12277,(#12281,#12288),.PCURVE_S1.); +#12277 = LINE('',#12278,#12279); +#12278 = CARTESIAN_POINT('',(22.000000000023,62.599999999996,31.5)); +#12279 = VECTOR('',#12280,1.); +#12280 = DIRECTION('',(-5.88029709377E-29,-1.870159327101E-15,-1.)); +#12281 = PCURVE('',#2766,#12282); +#12282 = DEFINITIONAL_REPRESENTATION('',(#12283),#12287); +#12283 = LINE('',#12284,#12285); +#12284 = CARTESIAN_POINT('',(-13.35000000001,44.700000000037)); +#12285 = VECTOR('',#12286,1.); +#12286 = DIRECTION('',(1.,-3.996345356033E-31)); +#12287 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12288 = PCURVE('',#9931,#12289); +#12289 = DEFINITIONAL_REPRESENTATION('',(#12290),#12294); +#12290 = LINE('',#12291,#12292); +#12291 = CARTESIAN_POINT('',(3.740318654202E-15,2.)); +#12292 = VECTOR('',#12293,1.); +#12293 = DIRECTION('',(1.,3.944304526105E-31)); +#12294 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12295 = ORIENTED_EDGE('',*,*,#12296,.T.); +#12296 = EDGE_CURVE('',#12274,#12249,#12297,.T.); +#12297 = SURFACE_CURVE('',#12298,(#12302,#12309),.PCURVE_S1.); +#12298 = LINE('',#12299,#12300); +#12299 = CARTESIAN_POINT('',(19.149999999975,62.599999999996,31.8)); +#12300 = VECTOR('',#12301,1.); +#12301 = DIRECTION('',(-0.707106781187,-1.656092836981E-15, + 0.707106781187)); +#12302 = PCURVE('',#2766,#12303); +#12303 = DEFINITIONAL_REPRESENTATION('',(#12304),#12308); +#12304 = LINE('',#12305,#12306); +#12305 = CARTESIAN_POINT('',(-13.65000000001,41.849999999989)); +#12306 = VECTOR('',#12307,1.); +#12307 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12308 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12309 = PCURVE('',#9903,#12310); +#12310 = DEFINITIONAL_REPRESENTATION('',(#12311),#12315); +#12311 = LINE('',#12312,#12313); +#12312 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12313 = VECTOR('',#12314,1.); +#12314 = DIRECTION('',(1.,3.871099052181E-31)); +#12315 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12316 = ADVANCED_FACE('',(#12317,#12649,#12652,#12655,#12661,#12664, + #12667,#12673,#12679),#2685,.F.); +#12317 = FACE_BOUND('',#12318,.T.); +#12318 = EDGE_LOOP('',(#12319,#12320,#12321,#12322,#12323,#12324,#12347, + #12370,#12393,#12416,#12439,#12462,#12485,#12508,#12531,#12554, + #12577,#12600,#12621,#12622,#12623,#12624,#12625,#12646,#12647, + #12648)); +#12319 = ORIENTED_EDGE('',*,*,#2778,.T.); +#12320 = ORIENTED_EDGE('',*,*,#11168,.F.); +#12321 = ORIENTED_EDGE('',*,*,#11014,.T.); +#12322 = ORIENTED_EDGE('',*,*,#4428,.T.); +#12323 = ORIENTED_EDGE('',*,*,#4501,.T.); +#12324 = ORIENTED_EDGE('',*,*,#12325,.T.); +#12325 = EDGE_CURVE('',#4479,#12326,#12328,.T.); +#12326 = VERTEX_POINT('',#12327); +#12327 = CARTESIAN_POINT('',(27.000000000023,19.400000000001,36.5)); +#12328 = SURFACE_CURVE('',#12329,(#12333,#12340),.PCURVE_S1.); +#12329 = LINE('',#12330,#12331); +#12330 = CARTESIAN_POINT('',(27.000000000023,-32.3,36.5)); +#12331 = VECTOR('',#12332,1.); +#12332 = DIRECTION('',(2.474800550248E-15,-1.,1.798273018971E-15)); +#12333 = PCURVE('',#2685,#12334); +#12334 = DEFINITIONAL_REPRESENTATION('',(#12335),#12339); +#12335 = LINE('',#12336,#12337); +#12336 = CARTESIAN_POINT('',(29.000000000014,-32.29999999999)); +#12337 = VECTOR('',#12338,1.); +#12338 = DIRECTION('',(2.474800550248E-15,-1.)); +#12339 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12340 = PCURVE('',#4150,#12341); +#12341 = DEFINITIONAL_REPRESENTATION('',(#12342),#12346); +#12342 = LINE('',#12343,#12344); +#12343 = CARTESIAN_POINT('',(32.299999999999,32.)); +#12344 = VECTOR('',#12345,1.); +#12345 = DIRECTION('',(-1.,1.675808339056E-15)); +#12346 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12347 = ORIENTED_EDGE('',*,*,#12348,.T.); +#12348 = EDGE_CURVE('',#12326,#12349,#12351,.T.); +#12349 = VERTEX_POINT('',#12350); +#12350 = CARTESIAN_POINT('',(22.000000000023,19.400000000001,36.5)); +#12351 = SURFACE_CURVE('',#12352,(#12356,#12363),.PCURVE_S1.); +#12352 = LINE('',#12353,#12354); +#12353 = CARTESIAN_POINT('',(12.500000000016,19.400000000001,36.5)); +#12354 = VECTOR('',#12355,1.); +#12355 = DIRECTION('',(-1.,-2.6645352591E-15,-1.018942737706E-15)); +#12356 = PCURVE('',#2685,#12357); +#12357 = DEFINITIONAL_REPRESENTATION('',(#12358),#12362); +#12358 = LINE('',#12359,#12360); +#12359 = CARTESIAN_POINT('',(14.500000000007,19.400000000003)); +#12360 = VECTOR('',#12361,1.); +#12361 = DIRECTION('',(-1.,-2.6645352591E-15)); +#12362 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12363 = PCURVE('',#4122,#12364); +#12364 = DEFINITIONAL_REPRESENTATION('',(#12365),#12369); +#12365 = LINE('',#12366,#12367); +#12366 = CARTESIAN_POINT('',(9.947598300642E-14,14.500000000007)); +#12367 = VECTOR('',#12368,1.); +#12368 = DIRECTION('',(1.018942737707E-15,1.)); +#12369 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12370 = ORIENTED_EDGE('',*,*,#12371,.T.); +#12371 = EDGE_CURVE('',#12349,#12372,#12374,.T.); +#12372 = VERTEX_POINT('',#12373); +#12373 = CARTESIAN_POINT('',(22.000000000023,13.400000000001,36.5)); +#12374 = SURFACE_CURVE('',#12375,(#12379,#12386),.PCURVE_S1.); +#12375 = LINE('',#12376,#12377); +#12376 = CARTESIAN_POINT('',(22.000000000023,8.2,36.5)); +#12377 = VECTOR('',#12378,1.); +#12378 = DIRECTION('',(2.443406931777E-15,-1.,1.798273018971E-15)); +#12379 = PCURVE('',#2685,#12380); +#12380 = DEFINITIONAL_REPRESENTATION('',(#12381),#12385); +#12381 = LINE('',#12382,#12383); +#12382 = CARTESIAN_POINT('',(24.000000000014,8.200000000001)); +#12383 = VECTOR('',#12384,1.); +#12384 = DIRECTION('',(2.443406931777E-15,-1.)); +#12385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12386 = PCURVE('',#4094,#12387); +#12387 = DEFINITIONAL_REPRESENTATION('',(#12388),#12392); +#12388 = LINE('',#12389,#12390); +#12389 = CARTESIAN_POINT('',(8.200000000001,16.)); +#12390 = VECTOR('',#12391,1.); +#12391 = DIRECTION('',(1.,1.675808339056E-15)); +#12392 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12393 = ORIENTED_EDGE('',*,*,#12394,.T.); +#12394 = EDGE_CURVE('',#12372,#12395,#12397,.T.); +#12395 = VERTEX_POINT('',#12396); +#12396 = CARTESIAN_POINT('',(27.000000000023,13.400000000001,36.5)); +#12397 = SURFACE_CURVE('',#12398,(#12402,#12409),.PCURVE_S1.); +#12398 = LINE('',#12399,#12400); +#12399 = CARTESIAN_POINT('',(12.500000000016,13.400000000001,36.5)); +#12400 = VECTOR('',#12401,1.); +#12401 = DIRECTION('',(1.,2.6645352591E-15,1.018942737706E-15)); +#12402 = PCURVE('',#2685,#12403); +#12403 = DEFINITIONAL_REPRESENTATION('',(#12404),#12408); +#12404 = LINE('',#12405,#12406); +#12405 = CARTESIAN_POINT('',(14.500000000007,13.400000000003)); +#12406 = VECTOR('',#12407,1.); +#12407 = DIRECTION('',(1.,2.6645352591E-15)); +#12408 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12409 = PCURVE('',#4066,#12410); +#12410 = DEFINITIONAL_REPRESENTATION('',(#12411),#12415); +#12411 = LINE('',#12412,#12413); +#12412 = CARTESIAN_POINT('',(32.,14.500000000007)); +#12413 = VECTOR('',#12414,1.); +#12414 = DIRECTION('',(1.018942737707E-15,-1.)); +#12415 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12416 = ORIENTED_EDGE('',*,*,#12417,.T.); +#12417 = EDGE_CURVE('',#12395,#12418,#12420,.T.); +#12418 = VERTEX_POINT('',#12419); +#12419 = CARTESIAN_POINT('',(27.000000000023,3.400000000001,36.5)); +#12420 = SURFACE_CURVE('',#12421,(#12425,#12432),.PCURVE_S1.); +#12421 = LINE('',#12422,#12423); +#12422 = CARTESIAN_POINT('',(27.000000000023,-32.3,36.5)); +#12423 = VECTOR('',#12424,1.); +#12424 = DIRECTION('',(2.474800550248E-15,-1.,1.798273018971E-15)); +#12425 = PCURVE('',#2685,#12426); +#12426 = DEFINITIONAL_REPRESENTATION('',(#12427),#12431); +#12427 = LINE('',#12428,#12429); +#12428 = CARTESIAN_POINT('',(29.000000000014,-32.29999999999)); +#12429 = VECTOR('',#12430,1.); +#12430 = DIRECTION('',(2.474800550248E-15,-1.)); +#12431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12432 = PCURVE('',#4038,#12433); +#12433 = DEFINITIONAL_REPRESENTATION('',(#12434),#12438); +#12434 = LINE('',#12435,#12436); +#12435 = CARTESIAN_POINT('',(32.299999999999,32.)); +#12436 = VECTOR('',#12437,1.); +#12437 = DIRECTION('',(-1.,1.675808339056E-15)); +#12438 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12439 = ORIENTED_EDGE('',*,*,#12440,.T.); +#12440 = EDGE_CURVE('',#12418,#12441,#12443,.T.); +#12441 = VERTEX_POINT('',#12442); +#12442 = CARTESIAN_POINT('',(22.000000000023,3.400000000001,36.5)); +#12443 = SURFACE_CURVE('',#12444,(#12448,#12455),.PCURVE_S1.); +#12444 = LINE('',#12445,#12446); +#12445 = CARTESIAN_POINT('',(12.500000000016,3.400000000001,36.5)); +#12446 = VECTOR('',#12447,1.); +#12447 = DIRECTION('',(-1.,-2.442490654175E-15,-1.018942737706E-15)); +#12448 = PCURVE('',#2685,#12449); +#12449 = DEFINITIONAL_REPRESENTATION('',(#12450),#12454); +#12450 = LINE('',#12451,#12452); +#12451 = CARTESIAN_POINT('',(14.500000000007,3.400000000003)); +#12452 = VECTOR('',#12453,1.); +#12453 = DIRECTION('',(-1.,-2.442490654175E-15)); +#12454 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12455 = PCURVE('',#4010,#12456); +#12456 = DEFINITIONAL_REPRESENTATION('',(#12457),#12461); +#12457 = LINE('',#12458,#12459); +#12458 = CARTESIAN_POINT('',(9.947598300642E-14,14.500000000007)); +#12459 = VECTOR('',#12460,1.); +#12460 = DIRECTION('',(1.018942737707E-15,1.)); +#12461 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12462 = ORIENTED_EDGE('',*,*,#12463,.T.); +#12463 = EDGE_CURVE('',#12441,#12464,#12466,.T.); +#12464 = VERTEX_POINT('',#12465); +#12465 = CARTESIAN_POINT('',(22.000000000023,-2.599999999999,36.5)); +#12466 = SURFACE_CURVE('',#12467,(#12471,#12478),.PCURVE_S1.); +#12467 = LINE('',#12468,#12469); +#12468 = CARTESIAN_POINT('',(22.000000000023,0.2,36.5)); +#12469 = VECTOR('',#12470,1.); +#12470 = DIRECTION('',(2.443406931777E-15,-1.,1.798273018971E-15)); +#12471 = PCURVE('',#2685,#12472); +#12472 = DEFINITIONAL_REPRESENTATION('',(#12473),#12477); +#12473 = LINE('',#12474,#12475); +#12474 = CARTESIAN_POINT('',(24.000000000014,0.200000000001)); +#12475 = VECTOR('',#12476,1.); +#12476 = DIRECTION('',(2.443406931777E-15,-1.)); +#12477 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12478 = PCURVE('',#3982,#12479); +#12479 = DEFINITIONAL_REPRESENTATION('',(#12480),#12484); +#12480 = LINE('',#12481,#12482); +#12481 = CARTESIAN_POINT('',(0.200000000001,16.)); +#12482 = VECTOR('',#12483,1.); +#12483 = DIRECTION('',(1.,1.675808339056E-15)); +#12484 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12485 = ORIENTED_EDGE('',*,*,#12486,.T.); +#12486 = EDGE_CURVE('',#12464,#12487,#12489,.T.); +#12487 = VERTEX_POINT('',#12488); +#12488 = CARTESIAN_POINT('',(27.000000000023,-2.599999999999,36.5)); +#12489 = SURFACE_CURVE('',#12490,(#12494,#12501),.PCURVE_S1.); +#12490 = LINE('',#12491,#12492); +#12491 = CARTESIAN_POINT('',(12.500000000016,-2.599999999999,36.5)); +#12492 = VECTOR('',#12493,1.); +#12493 = DIRECTION('',(1.,2.442490654175E-15,1.018942737706E-15)); +#12494 = PCURVE('',#2685,#12495); +#12495 = DEFINITIONAL_REPRESENTATION('',(#12496),#12500); +#12496 = LINE('',#12497,#12498); +#12497 = CARTESIAN_POINT('',(14.500000000007,-2.599999999997)); +#12498 = VECTOR('',#12499,1.); +#12499 = DIRECTION('',(1.,2.442490654175E-15)); +#12500 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12501 = PCURVE('',#3954,#12502); +#12502 = DEFINITIONAL_REPRESENTATION('',(#12503),#12507); +#12503 = LINE('',#12504,#12505); +#12504 = CARTESIAN_POINT('',(32.,14.500000000007)); +#12505 = VECTOR('',#12506,1.); +#12506 = DIRECTION('',(1.018942737707E-15,-1.)); +#12507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12508 = ORIENTED_EDGE('',*,*,#12509,.T.); +#12509 = EDGE_CURVE('',#12487,#12510,#12512,.T.); +#12510 = VERTEX_POINT('',#12511); +#12511 = CARTESIAN_POINT('',(27.000000000023,-52.59999999999,36.5)); +#12512 = SURFACE_CURVE('',#12513,(#12517,#12524),.PCURVE_S1.); +#12513 = LINE('',#12514,#12515); +#12514 = CARTESIAN_POINT('',(27.000000000023,-32.3,36.5)); +#12515 = VECTOR('',#12516,1.); +#12516 = DIRECTION('',(2.474800550248E-15,-1.,1.798273018971E-15)); +#12517 = PCURVE('',#2685,#12518); +#12518 = DEFINITIONAL_REPRESENTATION('',(#12519),#12523); +#12519 = LINE('',#12520,#12521); +#12520 = CARTESIAN_POINT('',(29.000000000014,-32.29999999999)); +#12521 = VECTOR('',#12522,1.); +#12522 = DIRECTION('',(2.474800550248E-15,-1.)); +#12523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12524 = PCURVE('',#3926,#12525); +#12525 = DEFINITIONAL_REPRESENTATION('',(#12526),#12530); +#12526 = LINE('',#12527,#12528); +#12527 = CARTESIAN_POINT('',(32.299999999999,32.)); +#12528 = VECTOR('',#12529,1.); +#12529 = DIRECTION('',(-1.,1.675808339056E-15)); +#12530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12531 = ORIENTED_EDGE('',*,*,#12532,.T.); +#12532 = EDGE_CURVE('',#12510,#12533,#12535,.T.); +#12533 = VERTEX_POINT('',#12534); +#12534 = CARTESIAN_POINT('',(22.000000000023,-52.59999999999,36.5)); +#12535 = SURFACE_CURVE('',#12536,(#12540,#12547),.PCURVE_S1.); +#12536 = LINE('',#12537,#12538); +#12537 = CARTESIAN_POINT('',(12.500000000016,-52.59999999999,36.5)); +#12538 = VECTOR('',#12539,1.); +#12539 = DIRECTION('',(-1.,-1.7763568394E-15,-1.018942737707E-15)); +#12540 = PCURVE('',#2685,#12541); +#12541 = DEFINITIONAL_REPRESENTATION('',(#12542),#12546); +#12542 = LINE('',#12543,#12544); +#12543 = CARTESIAN_POINT('',(14.500000000007,-52.59999999999)); +#12544 = VECTOR('',#12545,1.); +#12545 = DIRECTION('',(-1.,-1.7763568394E-15)); +#12546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12547 = PCURVE('',#3898,#12548); +#12548 = DEFINITIONAL_REPRESENTATION('',(#12549),#12553); +#12549 = LINE('',#12550,#12551); +#12550 = CARTESIAN_POINT('',(1.984175561965E-27,14.500000000007)); +#12551 = VECTOR('',#12552,1.); +#12552 = DIRECTION('',(1.018942737707E-15,1.)); +#12553 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12554 = ORIENTED_EDGE('',*,*,#12555,.T.); +#12555 = EDGE_CURVE('',#12533,#12556,#12558,.T.); +#12556 = VERTEX_POINT('',#12557); +#12557 = CARTESIAN_POINT('',(22.000000000023,-62.59999999999,36.5)); +#12558 = SURFACE_CURVE('',#12559,(#12563,#12570),.PCURVE_S1.); +#12559 = LINE('',#12560,#12561); +#12560 = CARTESIAN_POINT('',(22.000000000023,-28.8,36.5)); +#12561 = VECTOR('',#12562,1.); +#12562 = DIRECTION('',(2.443406931777E-15,-1.,1.798273018971E-15)); +#12563 = PCURVE('',#2685,#12564); +#12564 = DEFINITIONAL_REPRESENTATION('',(#12565),#12569); +#12565 = LINE('',#12566,#12567); +#12566 = CARTESIAN_POINT('',(24.000000000014,-28.79999999999)); +#12567 = VECTOR('',#12568,1.); +#12568 = DIRECTION('',(2.443406931777E-15,-1.)); +#12569 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12570 = PCURVE('',#3870,#12571); +#12571 = DEFINITIONAL_REPRESENTATION('',(#12572),#12576); +#12572 = LINE('',#12573,#12574); +#12573 = CARTESIAN_POINT('',(-5.,35.800000000103)); +#12574 = VECTOR('',#12575,1.); +#12575 = DIRECTION('',(-1.712812218996E-15,-1.)); +#12576 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12577 = ORIENTED_EDGE('',*,*,#12578,.F.); +#12578 = EDGE_CURVE('',#12579,#12556,#12581,.T.); +#12579 = VERTEX_POINT('',#12580); +#12580 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,36.5)); +#12581 = SURFACE_CURVE('',#12582,(#12586,#12593),.PCURVE_S1.); +#12582 = LINE('',#12583,#12584); +#12583 = CARTESIAN_POINT('',(-12.35000000009,-62.60000000005,36.5)); +#12584 = VECTOR('',#12585,1.); +#12585 = DIRECTION('',(1.,-1.439293502184E-12,1.018942737709E-15)); +#12586 = PCURVE('',#2685,#12587); +#12587 = DEFINITIONAL_REPRESENTATION('',(#12588),#12592); +#12588 = LINE('',#12589,#12590); +#12589 = CARTESIAN_POINT('',(-10.3500000001,-62.60000000005)); +#12590 = VECTOR('',#12591,1.); +#12591 = DIRECTION('',(1.,-1.439293502184E-12)); +#12592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12593 = PCURVE('',#3842,#12594); +#12594 = DEFINITIONAL_REPRESENTATION('',(#12595),#12599); +#12595 = LINE('',#12596,#12597); +#12596 = CARTESIAN_POINT('',(-18.35000000001,10.350000000012)); +#12597 = VECTOR('',#12598,1.); +#12598 = DIRECTION('',(-1.018942737708E-15,1.)); +#12599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12600 = ORIENTED_EDGE('',*,*,#12601,.T.); +#12601 = EDGE_CURVE('',#12579,#5533,#12602,.T.); +#12602 = SURFACE_CURVE('',#12603,(#12607,#12614),.PCURVE_S1.); +#12603 = LINE('',#12604,#12605); +#12604 = CARTESIAN_POINT('',(-25.49999999994,-19.3,36.5)); +#12605 = VECTOR('',#12606,1.); +#12606 = DIRECTION('',(-6.459479416001E-15,1.,-1.798273018971E-15)); +#12607 = PCURVE('',#2685,#12608); +#12608 = DEFINITIONAL_REPRESENTATION('',(#12609),#12613); +#12609 = LINE('',#12610,#12611); +#12610 = CARTESIAN_POINT('',(-23.49999999995,-19.29999999999)); +#12611 = VECTOR('',#12612,1.); +#12612 = DIRECTION('',(-6.459479416001E-15,1.)); +#12613 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12614 = PCURVE('',#3814,#12615); +#12615 = DEFINITIONAL_REPRESENTATION('',(#12616),#12620); +#12616 = LINE('',#12617,#12618); +#12617 = CARTESIAN_POINT('',(-32.,19.299999999999)); +#12618 = VECTOR('',#12619,1.); +#12619 = DIRECTION('',(1.675808339056E-15,1.)); +#12620 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12621 = ORIENTED_EDGE('',*,*,#5532,.T.); +#12622 = ORIENTED_EDGE('',*,*,#5483,.T.); +#12623 = ORIENTED_EDGE('',*,*,#5365,.T.); +#12624 = ORIENTED_EDGE('',*,*,#5316,.T.); +#12625 = ORIENTED_EDGE('',*,*,#12626,.T.); +#12626 = EDGE_CURVE('',#5294,#11118,#12627,.T.); +#12627 = SURFACE_CURVE('',#12628,(#12632,#12639),.PCURVE_S1.); +#12628 = LINE('',#12629,#12630); +#12629 = CARTESIAN_POINT('',(-17.49999999999,40.599999999996,36.5)); +#12630 = VECTOR('',#12631,1.); +#12631 = DIRECTION('',(-1.,-3.10862446895E-15,-1.018942737706E-15)); +#12632 = PCURVE('',#2685,#12633); +#12633 = DEFINITIONAL_REPRESENTATION('',(#12634),#12638); +#12634 = LINE('',#12635,#12636); +#12635 = CARTESIAN_POINT('',(-15.5,40.599999999997)); +#12636 = VECTOR('',#12637,1.); +#12637 = DIRECTION('',(-1.,-3.10862446895E-15)); +#12638 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12639 = PCURVE('',#2870,#12640); +#12640 = DEFINITIONAL_REPRESENTATION('',(#12641),#12645); +#12641 = LINE('',#12642,#12643); +#12642 = CARTESIAN_POINT('',(15.500000000007,32.)); +#12643 = VECTOR('',#12644,1.); +#12644 = DIRECTION('',(-1.,-1.018942737707E-15)); +#12645 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12646 = ORIENTED_EDGE('',*,*,#11117,.T.); +#12647 = ORIENTED_EDGE('',*,*,#10938,.T.); +#12648 = ORIENTED_EDGE('',*,*,#2668,.T.); +#12649 = FACE_BOUND('',#12650,.T.); +#12650 = EDGE_LOOP('',(#12651)); +#12651 = ORIENTED_EDGE('',*,*,#10783,.T.); +#12652 = FACE_BOUND('',#12653,.T.); +#12653 = EDGE_LOOP('',(#12654)); +#12654 = ORIENTED_EDGE('',*,*,#10733,.T.); +#12655 = FACE_BOUND('',#12656,.T.); +#12656 = EDGE_LOOP('',(#12657,#12658,#12659,#12660)); +#12657 = ORIENTED_EDGE('',*,*,#10514,.T.); +#12658 = ORIENTED_EDGE('',*,*,#10585,.T.); +#12659 = ORIENTED_EDGE('',*,*,#10634,.T.); +#12660 = ORIENTED_EDGE('',*,*,#10683,.T.); +#12661 = FACE_BOUND('',#12662,.T.); +#12662 = EDGE_LOOP('',(#12663)); +#12663 = ORIENTED_EDGE('',*,*,#10487,.T.); +#12664 = FACE_BOUND('',#12665,.T.); +#12665 = EDGE_LOOP('',(#12666)); +#12666 = ORIENTED_EDGE('',*,*,#10437,.T.); +#12667 = FACE_BOUND('',#12668,.T.); +#12668 = EDGE_LOOP('',(#12669,#12670,#12671,#12672)); +#12669 = ORIENTED_EDGE('',*,*,#10218,.T.); +#12670 = ORIENTED_EDGE('',*,*,#10289,.T.); +#12671 = ORIENTED_EDGE('',*,*,#10338,.T.); +#12672 = ORIENTED_EDGE('',*,*,#10387,.T.); +#12673 = FACE_BOUND('',#12674,.T.); +#12674 = EDGE_LOOP('',(#12675,#12676,#12677,#12678)); +#12675 = ORIENTED_EDGE('',*,*,#10022,.T.); +#12676 = ORIENTED_EDGE('',*,*,#10093,.T.); +#12677 = ORIENTED_EDGE('',*,*,#10142,.T.); +#12678 = ORIENTED_EDGE('',*,*,#10191,.T.); +#12679 = FACE_BOUND('',#12680,.T.); +#12680 = EDGE_LOOP('',(#12681)); +#12681 = ORIENTED_EDGE('',*,*,#9995,.T.); +#12682 = ADVANCED_FACE('',(#12683),#12697,.T.); +#12683 = FACE_BOUND('',#12684,.T.); +#12684 = EDGE_LOOP('',(#12685,#12715,#12738,#12761)); +#12685 = ORIENTED_EDGE('',*,*,#12686,.F.); +#12686 = EDGE_CURVE('',#12687,#12689,#12691,.T.); +#12687 = VERTEX_POINT('',#12688); +#12688 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 13.949999999979)); +#12689 = VERTEX_POINT('',#12690); +#12690 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 13.449999999834)); +#12691 = SURFACE_CURVE('',#12692,(#12696,#12708),.PCURVE_S1.); +#12692 = LINE('',#12693,#12694); +#12693 = CARTESIAN_POINT('',(-43.85000000011,-62.6,31.8)); +#12694 = VECTOR('',#12695,1.); +#12695 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#12696 = PCURVE('',#12697,#12702); +#12697 = PLANE('',#12698); +#12698 = AXIS2_PLACEMENT_3D('',#12699,#12700,#12701); +#12699 = CARTESIAN_POINT('',(-2.00000000008,-62.60000000006,21.5)); +#12700 = DIRECTION('',(-1.439006993016E-12,-1.,1.833155447161E-15)); +#12701 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#12702 = DEFINITIONAL_REPRESENTATION('',(#12703),#12707); +#12703 = LINE('',#12704,#12705); +#12704 = CARTESIAN_POINT('',(-10.3,-41.85000000003)); +#12705 = VECTOR('',#12706,1.); +#12706 = DIRECTION('',(0.707106781187,0.707106781187)); +#12707 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12708 = PCURVE('',#7217,#12709); +#12709 = DEFINITIONAL_REPRESENTATION('',(#12710),#12714); +#12710 = LINE('',#12711,#12712); +#12711 = CARTESIAN_POINT('',(-5.830541613256E-16,2.)); +#12712 = VECTOR('',#12713,1.); +#12713 = DIRECTION('',(1.,1.854674126415E-29)); +#12714 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12715 = ORIENTED_EDGE('',*,*,#12716,.F.); +#12716 = EDGE_CURVE('',#12717,#12687,#12719,.T.); +#12717 = VERTEX_POINT('',#12718); +#12718 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,11.5)); +#12719 = SURFACE_CURVE('',#12720,(#12724,#12731),.PCURVE_S1.); +#12720 = LINE('',#12721,#12722); +#12721 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,11.5)); +#12722 = VECTOR('',#12723,1.); +#12723 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#12724 = PCURVE('',#12697,#12725); +#12725 = DEFINITIONAL_REPRESENTATION('',(#12726),#12730); +#12726 = LINE('',#12727,#12728); +#12727 = CARTESIAN_POINT('',(10.,-24.00000000001)); +#12728 = VECTOR('',#12729,1.); +#12729 = DIRECTION('',(-1.,-1.010960030769E-31)); +#12730 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12731 = PCURVE('',#7271,#12732); +#12732 = DEFINITIONAL_REPRESENTATION('',(#12733),#12737); +#12733 = LINE('',#12734,#12735); +#12734 = CARTESIAN_POINT('',(1.709215999494E-16,2.)); +#12735 = VECTOR('',#12736,1.); +#12736 = DIRECTION('',(1.,0.)); +#12737 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12738 = ORIENTED_EDGE('',*,*,#12739,.F.); +#12739 = EDGE_CURVE('',#12740,#12717,#12742,.T.); +#12740 = VERTEX_POINT('',#12741); +#12741 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003,11.5)); +#12742 = SURFACE_CURVE('',#12743,(#12747,#12754),.PCURVE_S1.); +#12743 = LINE('',#12744,#12745); +#12744 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#12745 = VECTOR('',#12746,1.); +#12746 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#12747 = PCURVE('',#12697,#12748); +#12748 = DEFINITIONAL_REPRESENTATION('',(#12749),#12753); +#12749 = LINE('',#12750,#12751); +#12750 = CARTESIAN_POINT('',(10.,24.000000000014)); +#12751 = VECTOR('',#12752,1.); +#12752 = DIRECTION('',(5.380986103007E-42,-1.)); +#12753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12754 = PCURVE('',#7245,#12755); +#12755 = DEFINITIONAL_REPRESENTATION('',(#12756),#12760); +#12756 = LINE('',#12757,#12758); +#12757 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#12758 = VECTOR('',#12759,1.); +#12759 = DIRECTION('',(1.,2.343516320473E-42)); +#12760 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12761 = ORIENTED_EDGE('',*,*,#12762,.T.); +#12762 = EDGE_CURVE('',#12740,#12689,#12763,.T.); +#12763 = SURFACE_CURVE('',#12764,(#12768,#12775),.PCURVE_S1.); +#12764 = LINE('',#12765,#12766); +#12765 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,4.5)); +#12766 = VECTOR('',#12767,1.); +#12767 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#12768 = PCURVE('',#12697,#12769); +#12769 = DEFINITIONAL_REPRESENTATION('',(#12770),#12774); +#12770 = LINE('',#12771,#12772); +#12771 = CARTESIAN_POINT('',(17.,-23.49999999986)); +#12772 = VECTOR('',#12773,1.); +#12773 = DIRECTION('',(-1.,1.23440142074E-27)); +#12774 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12775 = PCURVE('',#3814,#12776); +#12776 = DEFINITIONAL_REPRESENTATION('',(#12777),#12781); +#12777 = LINE('',#12778,#12779); +#12778 = CARTESIAN_POINT('',(-1.127170239725E-14,-24.)); +#12779 = VECTOR('',#12780,1.); +#12780 = DIRECTION('',(-1.,0.)); +#12781 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12782 = ADVANCED_FACE('',(#12783),#12797,.T.); +#12783 = FACE_BOUND('',#12784,.T.); +#12784 = EDGE_LOOP('',(#12785,#12815,#12838,#12861)); +#12785 = ORIENTED_EDGE('',*,*,#12786,.F.); +#12786 = EDGE_CURVE('',#12787,#12789,#12791,.T.); +#12787 = VERTEX_POINT('',#12788); +#12788 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 19.949999999979)); +#12789 = VERTEX_POINT('',#12790); +#12790 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 19.449999999834)); +#12791 = SURFACE_CURVE('',#12792,(#12796,#12808),.PCURVE_S1.); +#12792 = LINE('',#12793,#12794); +#12793 = CARTESIAN_POINT('',(-37.85000000011,-62.60000000001,31.8)); +#12794 = VECTOR('',#12795,1.); +#12795 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#12796 = PCURVE('',#12797,#12802); +#12797 = PLANE('',#12798); +#12798 = AXIS2_PLACEMENT_3D('',#12799,#12800,#12801); +#12799 = CARTESIAN_POINT('',(-2.00000000008,-62.60000000006,21.5)); +#12800 = DIRECTION('',(-1.439006993016E-12,-1.,1.833155447161E-15)); +#12801 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#12802 = DEFINITIONAL_REPRESENTATION('',(#12803),#12807); +#12803 = LINE('',#12804,#12805); +#12804 = CARTESIAN_POINT('',(-10.3,-35.85000000003)); +#12805 = VECTOR('',#12806,1.); +#12806 = DIRECTION('',(0.707106781187,0.707106781187)); +#12807 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12808 = PCURVE('',#7103,#12809); +#12809 = DEFINITIONAL_REPRESENTATION('',(#12810),#12814); +#12810 = LINE('',#12811,#12812); +#12811 = CARTESIAN_POINT('',(-4.194266816291E-15,2.)); +#12812 = VECTOR('',#12813,1.); +#12813 = DIRECTION('',(1.,1.854674126415E-29)); +#12814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12815 = ORIENTED_EDGE('',*,*,#12816,.F.); +#12816 = EDGE_CURVE('',#12817,#12787,#12819,.T.); +#12817 = VERTEX_POINT('',#12818); +#12818 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 16.949999999979)); +#12819 = SURFACE_CURVE('',#12820,(#12824,#12831),.PCURVE_S1.); +#12820 = LINE('',#12821,#12822); +#12821 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,11.5)); +#12822 = VECTOR('',#12823,1.); +#12823 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#12824 = PCURVE('',#12797,#12825); +#12825 = DEFINITIONAL_REPRESENTATION('',(#12826),#12830); +#12826 = LINE('',#12827,#12828); +#12827 = CARTESIAN_POINT('',(10.,-24.00000000001)); +#12828 = VECTOR('',#12829,1.); +#12829 = DIRECTION('',(-1.,-1.010960030769E-31)); +#12830 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12831 = PCURVE('',#7185,#12832); +#12832 = DEFINITIONAL_REPRESENTATION('',(#12833),#12837); +#12833 = LINE('',#12834,#12835); +#12834 = CARTESIAN_POINT('',(1.709215999494E-16,2.)); +#12835 = VECTOR('',#12836,1.); +#12836 = DIRECTION('',(1.,0.)); +#12837 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12838 = ORIENTED_EDGE('',*,*,#12839,.F.); +#12839 = EDGE_CURVE('',#12840,#12817,#12842,.T.); +#12840 = VERTEX_POINT('',#12841); +#12841 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 16.449999999833)); +#12842 = SURFACE_CURVE('',#12843,(#12847,#12854),.PCURVE_S1.); +#12843 = LINE('',#12844,#12845); +#12844 = CARTESIAN_POINT('',(-40.85000000011,-62.60000000001,31.8)); +#12845 = VECTOR('',#12846,1.); +#12846 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#12847 = PCURVE('',#12797,#12848); +#12848 = DEFINITIONAL_REPRESENTATION('',(#12849),#12853); +#12849 = LINE('',#12850,#12851); +#12850 = CARTESIAN_POINT('',(-10.3,-38.85000000003)); +#12851 = VECTOR('',#12852,1.); +#12852 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12853 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12854 = PCURVE('',#7159,#12855); +#12855 = DEFINITIONAL_REPRESENTATION('',(#12856),#12860); +#12856 = LINE('',#12857,#12858); +#12857 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12858 = VECTOR('',#12859,1.); +#12859 = DIRECTION('',(1.,-8.10752882526E-29)); +#12860 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12861 = ORIENTED_EDGE('',*,*,#12862,.T.); +#12862 = EDGE_CURVE('',#12840,#12789,#12863,.T.); +#12863 = SURFACE_CURVE('',#12864,(#12868,#12875),.PCURVE_S1.); +#12864 = LINE('',#12865,#12866); +#12865 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,4.5)); +#12866 = VECTOR('',#12867,1.); +#12867 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#12868 = PCURVE('',#12797,#12869); +#12869 = DEFINITIONAL_REPRESENTATION('',(#12870),#12874); +#12870 = LINE('',#12871,#12872); +#12871 = CARTESIAN_POINT('',(17.,-23.49999999986)); +#12872 = VECTOR('',#12873,1.); +#12873 = DIRECTION('',(-1.,1.23440142074E-27)); +#12874 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12875 = PCURVE('',#3814,#12876); +#12876 = DEFINITIONAL_REPRESENTATION('',(#12877),#12881); +#12877 = LINE('',#12878,#12879); +#12878 = CARTESIAN_POINT('',(-1.127170239725E-14,-24.)); +#12879 = VECTOR('',#12880,1.); +#12880 = DIRECTION('',(-1.,0.)); +#12881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12882 = ADVANCED_FACE('',(#12883),#12897,.T.); +#12883 = FACE_BOUND('',#12884,.T.); +#12884 = EDGE_LOOP('',(#12885,#12915,#12938,#12961)); +#12885 = ORIENTED_EDGE('',*,*,#12886,.F.); +#12886 = EDGE_CURVE('',#12887,#12889,#12891,.T.); +#12887 = VERTEX_POINT('',#12888); +#12888 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 25.949999999979)); +#12889 = VERTEX_POINT('',#12890); +#12890 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 25.449999999834)); +#12891 = SURFACE_CURVE('',#12892,(#12896,#12908),.PCURVE_S1.); +#12892 = LINE('',#12893,#12894); +#12893 = CARTESIAN_POINT('',(-31.85000000011,-62.60000000002,31.8)); +#12894 = VECTOR('',#12895,1.); +#12895 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#12896 = PCURVE('',#12897,#12902); +#12897 = PLANE('',#12898); +#12898 = AXIS2_PLACEMENT_3D('',#12899,#12900,#12901); +#12899 = CARTESIAN_POINT('',(-2.00000000008,-62.60000000006,21.5)); +#12900 = DIRECTION('',(-1.439006993016E-12,-1.,1.833155447161E-15)); +#12901 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#12902 = DEFINITIONAL_REPRESENTATION('',(#12903),#12907); +#12903 = LINE('',#12904,#12905); +#12904 = CARTESIAN_POINT('',(-10.3,-29.85000000003)); +#12905 = VECTOR('',#12906,1.); +#12906 = DIRECTION('',(0.707106781187,0.707106781187)); +#12907 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12908 = PCURVE('',#7303,#12909); +#12909 = DEFINITIONAL_REPRESENTATION('',(#12910),#12914); +#12910 = LINE('',#12911,#12912); +#12911 = CARTESIAN_POINT('',(1.715899062181E-14,2.)); +#12912 = VECTOR('',#12913,1.); +#12913 = DIRECTION('',(1.,1.854674126415E-29)); +#12914 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12915 = ORIENTED_EDGE('',*,*,#12916,.F.); +#12916 = EDGE_CURVE('',#12917,#12887,#12919,.T.); +#12917 = VERTEX_POINT('',#12918); +#12918 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 22.949999999979)); +#12919 = SURFACE_CURVE('',#12920,(#12924,#12931),.PCURVE_S1.); +#12920 = LINE('',#12921,#12922); +#12921 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,11.5)); +#12922 = VECTOR('',#12923,1.); +#12923 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#12924 = PCURVE('',#12897,#12925); +#12925 = DEFINITIONAL_REPRESENTATION('',(#12926),#12930); +#12926 = LINE('',#12927,#12928); +#12927 = CARTESIAN_POINT('',(10.,-24.00000000001)); +#12928 = VECTOR('',#12929,1.); +#12929 = DIRECTION('',(-1.,-1.010960030769E-31)); +#12930 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12931 = PCURVE('',#7385,#12932); +#12932 = DEFINITIONAL_REPRESENTATION('',(#12933),#12937); +#12933 = LINE('',#12934,#12935); +#12934 = CARTESIAN_POINT('',(1.709215999494E-16,2.)); +#12935 = VECTOR('',#12936,1.); +#12936 = DIRECTION('',(1.,0.)); +#12937 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12938 = ORIENTED_EDGE('',*,*,#12939,.F.); +#12939 = EDGE_CURVE('',#12940,#12917,#12942,.T.); +#12940 = VERTEX_POINT('',#12941); +#12941 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 22.449999999833)); +#12942 = SURFACE_CURVE('',#12943,(#12947,#12954),.PCURVE_S1.); +#12943 = LINE('',#12944,#12945); +#12944 = CARTESIAN_POINT('',(-34.85000000011,-62.60000000002,31.8)); +#12945 = VECTOR('',#12946,1.); +#12946 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#12947 = PCURVE('',#12897,#12948); +#12948 = DEFINITIONAL_REPRESENTATION('',(#12949),#12953); +#12949 = LINE('',#12950,#12951); +#12950 = CARTESIAN_POINT('',(-10.3,-32.85000000003)); +#12951 = VECTOR('',#12952,1.); +#12952 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#12953 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12954 = PCURVE('',#7359,#12955); +#12955 = DEFINITIONAL_REPRESENTATION('',(#12956),#12960); +#12956 = LINE('',#12957,#12958); +#12957 = CARTESIAN_POINT('',(35.779603128055,2.)); +#12958 = VECTOR('',#12959,1.); +#12959 = DIRECTION('',(1.,-8.10752882526E-29)); +#12960 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12961 = ORIENTED_EDGE('',*,*,#12962,.T.); +#12962 = EDGE_CURVE('',#12940,#12889,#12963,.T.); +#12963 = SURFACE_CURVE('',#12964,(#12968,#12975),.PCURVE_S1.); +#12964 = LINE('',#12965,#12966); +#12965 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,4.5)); +#12966 = VECTOR('',#12967,1.); +#12967 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#12968 = PCURVE('',#12897,#12969); +#12969 = DEFINITIONAL_REPRESENTATION('',(#12970),#12974); +#12970 = LINE('',#12971,#12972); +#12971 = CARTESIAN_POINT('',(17.,-23.49999999986)); +#12972 = VECTOR('',#12973,1.); +#12973 = DIRECTION('',(-1.,1.23440142074E-27)); +#12974 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12975 = PCURVE('',#3814,#12976); +#12976 = DEFINITIONAL_REPRESENTATION('',(#12977),#12981); +#12977 = LINE('',#12978,#12979); +#12978 = CARTESIAN_POINT('',(-1.127170239725E-14,-24.)); +#12979 = VECTOR('',#12980,1.); +#12980 = DIRECTION('',(-1.,0.)); +#12981 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#12982 = ADVANCED_FACE('',(#12983),#12997,.T.); +#12983 = FACE_BOUND('',#12984,.T.); +#12984 = EDGE_LOOP('',(#12985,#13015,#13038,#13061,#13084)); +#12985 = ORIENTED_EDGE('',*,*,#12986,.F.); +#12986 = EDGE_CURVE('',#12987,#12989,#12991,.T.); +#12987 = VERTEX_POINT('',#12988); +#12988 = CARTESIAN_POINT('',(-25.55000000011,-62.60000000003,31.5)); +#12989 = VERTEX_POINT('',#12990); +#12990 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 31.449999999833)); +#12991 = SURFACE_CURVE('',#12992,(#12996,#13008),.PCURVE_S1.); +#12992 = LINE('',#12993,#12994); +#12993 = CARTESIAN_POINT('',(-25.85000000011,-62.60000000003,31.8)); +#12994 = VECTOR('',#12995,1.); +#12995 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#12996 = PCURVE('',#12997,#13002); +#12997 = PLANE('',#12998); +#12998 = AXIS2_PLACEMENT_3D('',#12999,#13000,#13001); +#12999 = CARTESIAN_POINT('',(-2.00000000008,-62.60000000006,21.5)); +#13000 = DIRECTION('',(-1.439006993016E-12,-1.,1.833155447161E-15)); +#13001 = DIRECTION('',(-1.293459215968E-27,-1.833155447161E-15,-1.)); +#13002 = DEFINITIONAL_REPRESENTATION('',(#13003),#13007); +#13003 = LINE('',#13004,#13005); +#13004 = CARTESIAN_POINT('',(-10.3,-23.85000000003)); +#13005 = VECTOR('',#13006,1.); +#13006 = DIRECTION('',(0.707106781187,0.707106781187)); +#13007 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13008 = PCURVE('',#7526,#13009); +#13009 = DEFINITIONAL_REPRESENTATION('',(#13010),#13014); +#13010 = LINE('',#13011,#13012); +#13011 = CARTESIAN_POINT('',(1.715899062179E-14,2.)); +#13012 = VECTOR('',#13013,1.); +#13013 = DIRECTION('',(1.,1.854674126415E-29)); +#13014 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13015 = ORIENTED_EDGE('',*,*,#13016,.F.); +#13016 = EDGE_CURVE('',#13017,#12987,#13019,.T.); +#13017 = VERTEX_POINT('',#13018); +#13018 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#13019 = SURFACE_CURVE('',#13020,(#13024,#13031),.PCURVE_S1.); +#13020 = LINE('',#13021,#13022); +#13021 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#13022 = VECTOR('',#13023,1.); +#13023 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#13024 = PCURVE('',#12997,#13025); +#13025 = DEFINITIONAL_REPRESENTATION('',(#13026),#13030); +#13026 = LINE('',#13027,#13028); +#13027 = CARTESIAN_POINT('',(-10.,-24.00000000001)); +#13028 = VECTOR('',#13029,1.); +#13029 = DIRECTION('',(-5.380986103007E-42,1.)); +#13030 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13031 = PCURVE('',#7636,#13032); +#13032 = DEFINITIONAL_REPRESENTATION('',(#13033),#13037); +#13033 = LINE('',#13034,#13035); +#13034 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#13035 = VECTOR('',#13036,1.); +#13036 = DIRECTION('',(1.,-2.343516320473E-42)); +#13037 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13038 = ORIENTED_EDGE('',*,*,#13039,.F.); +#13039 = EDGE_CURVE('',#13040,#13017,#13042,.T.); +#13040 = VERTEX_POINT('',#13041); +#13041 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003, + 28.949999999979)); +#13042 = SURFACE_CURVE('',#13043,(#13047,#13054),.PCURVE_S1.); +#13043 = LINE('',#13044,#13045); +#13044 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,11.5)); +#13045 = VECTOR('',#13046,1.); +#13046 = DIRECTION('',(-1.221586698994E-27,8.54607999747E-17,1.)); +#13047 = PCURVE('',#12997,#13048); +#13048 = DEFINITIONAL_REPRESENTATION('',(#13049),#13053); +#13049 = LINE('',#13050,#13051); +#13050 = CARTESIAN_POINT('',(10.,-24.00000000001)); +#13051 = VECTOR('',#13052,1.); +#13052 = DIRECTION('',(-1.,-1.010960030769E-31)); +#13053 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13054 = PCURVE('',#7610,#13055); +#13055 = DEFINITIONAL_REPRESENTATION('',(#13056),#13060); +#13056 = LINE('',#13057,#13058); +#13057 = CARTESIAN_POINT('',(1.709215999494E-16,2.)); +#13058 = VECTOR('',#13059,1.); +#13059 = DIRECTION('',(1.,0.)); +#13060 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13061 = ORIENTED_EDGE('',*,*,#13062,.F.); +#13062 = EDGE_CURVE('',#13063,#13040,#13065,.T.); +#13063 = VERTEX_POINT('',#13064); +#13064 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999, + 28.449999999833)); +#13065 = SURFACE_CURVE('',#13066,(#13070,#13077),.PCURVE_S1.); +#13066 = LINE('',#13067,#13068); +#13067 = CARTESIAN_POINT('',(-28.85000000011,-62.60000000003,31.8)); +#13068 = VECTOR('',#13069,1.); +#13069 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#13070 = PCURVE('',#12997,#13071); +#13071 = DEFINITIONAL_REPRESENTATION('',(#13072),#13076); +#13072 = LINE('',#13073,#13074); +#13073 = CARTESIAN_POINT('',(-10.3,-26.85000000003)); +#13074 = VECTOR('',#13075,1.); +#13075 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#13076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13077 = PCURVE('',#7582,#13078); +#13078 = DEFINITIONAL_REPRESENTATION('',(#13079),#13083); +#13079 = LINE('',#13080,#13081); +#13080 = CARTESIAN_POINT('',(35.779603128055,2.)); +#13081 = VECTOR('',#13082,1.); +#13082 = DIRECTION('',(1.,-8.10752882526E-29)); +#13083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13084 = ORIENTED_EDGE('',*,*,#13085,.T.); +#13085 = EDGE_CURVE('',#13063,#12989,#13086,.T.); +#13086 = SURFACE_CURVE('',#13087,(#13091,#13098),.PCURVE_S1.); +#13087 = LINE('',#13088,#13089); +#13088 = CARTESIAN_POINT('',(-25.49999999994,-62.59999999999,4.5)); +#13089 = VECTOR('',#13090,1.); +#13090 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#13091 = PCURVE('',#12997,#13092); +#13092 = DEFINITIONAL_REPRESENTATION('',(#13093),#13097); +#13093 = LINE('',#13094,#13095); +#13094 = CARTESIAN_POINT('',(17.,-23.49999999986)); +#13095 = VECTOR('',#13096,1.); +#13096 = DIRECTION('',(-1.,1.23440142074E-27)); +#13097 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13098 = PCURVE('',#3814,#13099); +#13099 = DEFINITIONAL_REPRESENTATION('',(#13100),#13104); +#13100 = LINE('',#13101,#13102); +#13101 = CARTESIAN_POINT('',(-1.127170239725E-14,-24.)); +#13102 = VECTOR('',#13103,1.); +#13103 = DIRECTION('',(-1.,0.)); +#13104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13105 = ADVANCED_FACE('',(#13106),#13120,.F.); +#13106 = FACE_BOUND('',#13107,.F.); +#13107 = EDGE_LOOP('',(#13108,#13138,#13169,#13170)); +#13108 = ORIENTED_EDGE('',*,*,#13109,.T.); +#13109 = EDGE_CURVE('',#13110,#13112,#13114,.T.); +#13110 = VERTEX_POINT('',#13111); +#13111 = CARTESIAN_POINT('',(22.000000000023,-54.54999999999, + 9.500000000001)); +#13112 = VERTEX_POINT('',#13113); +#13113 = CARTESIAN_POINT('',(27.000000000023,-54.54999999999, + 9.500000000001)); +#13114 = SEAM_CURVE('',#13115,(#13119,#13131),.PCURVE_S1.); +#13115 = LINE('',#13116,#13117); +#13116 = CARTESIAN_POINT('',(27.000000000023,-54.54999999999, + 9.500000000001)); +#13117 = VECTOR('',#13118,1.); +#13118 = DIRECTION('',(1.,1.7763568394E-15,-6.638220072313E-29)); +#13119 = PCURVE('',#13120,#13125); +#13120 = CYLINDRICAL_SURFACE('',#13121,1.05); +#13121 = AXIS2_PLACEMENT_3D('',#13122,#13123,#13124); +#13122 = CARTESIAN_POINT('',(27.000000000023,-55.59999999999, + 9.500000000001)); +#13123 = DIRECTION('',(-1.,-1.7763568394E-15,6.638220072313E-29)); +#13124 = DIRECTION('',(1.7763568394E-15,-1.,1.224646799147E-16)); +#13125 = DEFINITIONAL_REPRESENTATION('',(#13126),#13130); +#13126 = LINE('',#13127,#13128); +#13127 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13128 = VECTOR('',#13129,1.); +#13129 = DIRECTION('',(0.,-1.)); +#13130 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13131 = PCURVE('',#13120,#13132); +#13132 = DEFINITIONAL_REPRESENTATION('',(#13133),#13137); +#13133 = LINE('',#13134,#13135); +#13134 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13135 = VECTOR('',#13136,1.); +#13136 = DIRECTION('',(0.,-1.)); +#13137 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13138 = ORIENTED_EDGE('',*,*,#13139,.T.); +#13139 = EDGE_CURVE('',#13112,#13112,#13140,.T.); +#13140 = SURFACE_CURVE('',#13141,(#13146,#13153),.PCURVE_S1.); +#13141 = CIRCLE('',#13142,1.05); +#13142 = AXIS2_PLACEMENT_3D('',#13143,#13144,#13145); +#13143 = CARTESIAN_POINT('',(27.000000000023,-55.59999999999, + 9.500000000001)); +#13144 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13145 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13146 = PCURVE('',#13120,#13147); +#13147 = DEFINITIONAL_REPRESENTATION('',(#13148),#13152); +#13148 = LINE('',#13149,#13150); +#13149 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13150 = VECTOR('',#13151,1.); +#13151 = DIRECTION('',(1.,0.)); +#13152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13153 = PCURVE('',#13154,#13159); +#13154 = PLANE('',#13155); +#13155 = AXIS2_PLACEMENT_3D('',#13156,#13157,#13158); +#13156 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13157 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13158 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13159 = DEFINITIONAL_REPRESENTATION('',(#13160),#13168); +#13160 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13161,#13162,#13163,#13164 + ,#13165,#13166,#13167),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13161 = CARTESIAN_POINT('',(7.95,5.000000000001)); +#13162 = CARTESIAN_POINT('',(7.95,6.818653347948)); +#13163 = CARTESIAN_POINT('',(9.525,5.909326673974)); +#13164 = CARTESIAN_POINT('',(11.1,5.000000000001)); +#13165 = CARTESIAN_POINT('',(9.525,4.090673326027)); +#13166 = CARTESIAN_POINT('',(7.95,3.181346652053)); +#13167 = CARTESIAN_POINT('',(7.95,5.000000000001)); +#13168 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13169 = ORIENTED_EDGE('',*,*,#13109,.F.); +#13170 = ORIENTED_EDGE('',*,*,#13171,.T.); +#13171 = EDGE_CURVE('',#13110,#13110,#13172,.T.); +#13172 = SURFACE_CURVE('',#13173,(#13178,#13185),.PCURVE_S1.); +#13173 = CIRCLE('',#13174,1.05); +#13174 = AXIS2_PLACEMENT_3D('',#13175,#13176,#13177); +#13175 = CARTESIAN_POINT('',(22.000000000023,-55.59999999999, + 9.500000000001)); +#13176 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13177 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13178 = PCURVE('',#13120,#13179); +#13179 = DEFINITIONAL_REPRESENTATION('',(#13180),#13184); +#13180 = LINE('',#13181,#13182); +#13181 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13182 = VECTOR('',#13183,1.); +#13183 = DIRECTION('',(-1.,0.)); +#13184 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13185 = PCURVE('',#3870,#13186); +#13186 = DEFINITIONAL_REPRESENTATION('',(#13187),#13191); +#13187 = CIRCLE('',#13188,1.05); +#13188 = AXIS2_PLACEMENT_2D('',#13189,#13190); +#13189 = CARTESIAN_POINT('',(21.999999999999,9.000000000104)); +#13190 = DIRECTION('',(-3.700387994003E-17,-1.)); +#13191 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13192 = ADVANCED_FACE('',(#13193),#13207,.F.); +#13193 = FACE_BOUND('',#13194,.F.); +#13194 = EDGE_LOOP('',(#13195,#13225,#13256,#13257)); +#13195 = ORIENTED_EDGE('',*,*,#13196,.T.); +#13196 = EDGE_CURVE('',#13197,#13199,#13201,.T.); +#13197 = VERTEX_POINT('',#13198); +#13198 = CARTESIAN_POINT('',(22.000000000023,-54.54999999999, + 28.800000000001)); +#13199 = VERTEX_POINT('',#13200); +#13200 = CARTESIAN_POINT('',(27.000000000023,-54.54999999999, + 28.800000000001)); +#13201 = SEAM_CURVE('',#13202,(#13206,#13218),.PCURVE_S1.); +#13202 = LINE('',#13203,#13204); +#13203 = CARTESIAN_POINT('',(27.000000000023,-54.54999999999, + 28.800000000001)); +#13204 = VECTOR('',#13205,1.); +#13205 = DIRECTION('',(1.,1.7763568394E-15,-6.638220072313E-29)); +#13206 = PCURVE('',#13207,#13212); +#13207 = CYLINDRICAL_SURFACE('',#13208,1.05); +#13208 = AXIS2_PLACEMENT_3D('',#13209,#13210,#13211); +#13209 = CARTESIAN_POINT('',(27.000000000023,-55.59999999999, + 28.800000000001)); +#13210 = DIRECTION('',(-1.,-1.7763568394E-15,6.638220072313E-29)); +#13211 = DIRECTION('',(1.7763568394E-15,-1.,1.224646799147E-16)); +#13212 = DEFINITIONAL_REPRESENTATION('',(#13213),#13217); +#13213 = LINE('',#13214,#13215); +#13214 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13215 = VECTOR('',#13216,1.); +#13216 = DIRECTION('',(0.,-1.)); +#13217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13218 = PCURVE('',#13207,#13219); +#13219 = DEFINITIONAL_REPRESENTATION('',(#13220),#13224); +#13220 = LINE('',#13221,#13222); +#13221 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13222 = VECTOR('',#13223,1.); +#13223 = DIRECTION('',(0.,-1.)); +#13224 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13225 = ORIENTED_EDGE('',*,*,#13226,.T.); +#13226 = EDGE_CURVE('',#13199,#13199,#13227,.T.); +#13227 = SURFACE_CURVE('',#13228,(#13233,#13240),.PCURVE_S1.); +#13228 = CIRCLE('',#13229,1.05); +#13229 = AXIS2_PLACEMENT_3D('',#13230,#13231,#13232); +#13230 = CARTESIAN_POINT('',(27.000000000023,-55.59999999999, + 28.800000000001)); +#13231 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13232 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13233 = PCURVE('',#13207,#13234); +#13234 = DEFINITIONAL_REPRESENTATION('',(#13235),#13239); +#13235 = LINE('',#13236,#13237); +#13236 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13237 = VECTOR('',#13238,1.); +#13238 = DIRECTION('',(1.,0.)); +#13239 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13240 = PCURVE('',#13241,#13246); +#13241 = PLANE('',#13242); +#13242 = AXIS2_PLACEMENT_3D('',#13243,#13244,#13245); +#13243 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13244 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13245 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13246 = DEFINITIONAL_REPRESENTATION('',(#13247),#13255); +#13247 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13248,#13249,#13250,#13251 + ,#13252,#13253,#13254),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13248 = CARTESIAN_POINT('',(7.95,24.300000000001)); +#13249 = CARTESIAN_POINT('',(7.95,26.118653347948)); +#13250 = CARTESIAN_POINT('',(9.525,25.209326673974)); +#13251 = CARTESIAN_POINT('',(11.1,24.300000000001)); +#13252 = CARTESIAN_POINT('',(9.525,23.390673326027)); +#13253 = CARTESIAN_POINT('',(7.95,22.481346652053)); +#13254 = CARTESIAN_POINT('',(7.95,24.300000000001)); +#13255 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13256 = ORIENTED_EDGE('',*,*,#13196,.F.); +#13257 = ORIENTED_EDGE('',*,*,#13258,.T.); +#13258 = EDGE_CURVE('',#13197,#13197,#13259,.T.); +#13259 = SURFACE_CURVE('',#13260,(#13265,#13272),.PCURVE_S1.); +#13260 = CIRCLE('',#13261,1.05); +#13261 = AXIS2_PLACEMENT_3D('',#13262,#13263,#13264); +#13262 = CARTESIAN_POINT('',(22.000000000023,-55.59999999999, + 28.800000000001)); +#13263 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13264 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13265 = PCURVE('',#13207,#13266); +#13266 = DEFINITIONAL_REPRESENTATION('',(#13267),#13271); +#13267 = LINE('',#13268,#13269); +#13268 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13269 = VECTOR('',#13270,1.); +#13270 = DIRECTION('',(-1.,0.)); +#13271 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13272 = PCURVE('',#3870,#13273); +#13273 = DEFINITIONAL_REPRESENTATION('',(#13274),#13278); +#13274 = CIRCLE('',#13275,1.05); +#13275 = AXIS2_PLACEMENT_2D('',#13276,#13277); +#13276 = CARTESIAN_POINT('',(2.699999999999,9.000000000104)); +#13277 = DIRECTION('',(-3.700387994003E-17,-1.)); +#13278 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13279 = ADVANCED_FACE('',(#13280),#3898,.T.); +#13280 = FACE_BOUND('',#13281,.T.); +#13281 = EDGE_LOOP('',(#13282,#13303,#13304,#13325)); +#13282 = ORIENTED_EDGE('',*,*,#13283,.F.); +#13283 = EDGE_CURVE('',#3883,#12510,#13284,.T.); +#13284 = SURFACE_CURVE('',#13285,(#13289,#13296),.PCURVE_S1.); +#13285 = LINE('',#13286,#13287); +#13286 = CARTESIAN_POINT('',(27.000000000023,-52.59999999999,20.5)); +#13287 = VECTOR('',#13288,1.); +#13288 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#13289 = PCURVE('',#3898,#13290); +#13290 = DEFINITIONAL_REPRESENTATION('',(#13291),#13295); +#13291 = LINE('',#13292,#13293); +#13292 = CARTESIAN_POINT('',(16.,-2.189075035041E-27)); +#13293 = VECTOR('',#13294,1.); +#13294 = DIRECTION('',(-1.,4.270329215564E-30)); +#13295 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13296 = PCURVE('',#3926,#13297); +#13297 = DEFINITIONAL_REPRESENTATION('',(#13298),#13302); +#13298 = LINE('',#13299,#13300); +#13299 = CARTESIAN_POINT('',(12.,16.)); +#13300 = VECTOR('',#13301,1.); +#13301 = DIRECTION('',(0.,1.)); +#13302 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13303 = ORIENTED_EDGE('',*,*,#3882,.T.); +#13304 = ORIENTED_EDGE('',*,*,#13305,.F.); +#13305 = EDGE_CURVE('',#12533,#3855,#13306,.T.); +#13306 = SURFACE_CURVE('',#13307,(#13311,#13318),.PCURVE_S1.); +#13307 = LINE('',#13308,#13309); +#13308 = CARTESIAN_POINT('',(22.000000000023,-52.59999999999,36.5)); +#13309 = VECTOR('',#13310,1.); +#13310 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#13311 = PCURVE('',#3898,#13312); +#13312 = DEFINITIONAL_REPRESENTATION('',(#13313),#13317); +#13313 = LINE('',#13314,#13315); +#13314 = CARTESIAN_POINT('',(6.838684074787E-28,5.)); +#13315 = VECTOR('',#13316,1.); +#13316 = DIRECTION('',(1.,0.)); +#13317 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13318 = PCURVE('',#3870,#13319); +#13319 = DEFINITIONAL_REPRESENTATION('',(#13320),#13324); +#13320 = LINE('',#13321,#13322); +#13321 = CARTESIAN_POINT('',(-5.,12.000000000104)); +#13322 = VECTOR('',#13323,1.); +#13323 = DIRECTION('',(1.,-3.700387994003E-17)); +#13324 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13325 = ORIENTED_EDGE('',*,*,#12532,.F.); +#13326 = ADVANCED_FACE('',(#13327),#13241,.F.); +#13327 = FACE_BOUND('',#13328,.T.); +#13328 = EDGE_LOOP('',(#13329)); +#13329 = ORIENTED_EDGE('',*,*,#13226,.T.); +#13330 = ADVANCED_FACE('',(#13331,#13357),#3926,.F.); +#13331 = FACE_BOUND('',#13332,.T.); +#13332 = EDGE_LOOP('',(#13333,#13334,#13335,#13356)); +#13333 = ORIENTED_EDGE('',*,*,#13283,.T.); +#13334 = ORIENTED_EDGE('',*,*,#12509,.F.); +#13335 = ORIENTED_EDGE('',*,*,#13336,.T.); +#13336 = EDGE_CURVE('',#12487,#3911,#13337,.T.); +#13337 = SURFACE_CURVE('',#13338,(#13342,#13349),.PCURVE_S1.); +#13338 = LINE('',#13339,#13340); +#13339 = CARTESIAN_POINT('',(27.000000000023,-2.599999999999,4.5)); +#13340 = VECTOR('',#13341,1.); +#13341 = DIRECTION('',(-6.63363835359E-29,-5.307574087566E-17,-1.)); +#13342 = PCURVE('',#3926,#13343); +#13343 = DEFINITIONAL_REPRESENTATION('',(#13344),#13348); +#13344 = LINE('',#13345,#13346); +#13345 = CARTESIAN_POINT('',(62.,-6.618044560488E-15)); +#13346 = VECTOR('',#13347,1.); +#13347 = DIRECTION('',(6.938893903907E-17,-1.)); +#13348 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13349 = PCURVE('',#3954,#13350); +#13350 = DEFINITIONAL_REPRESENTATION('',(#13351),#13355); +#13351 = LINE('',#13352,#13353); +#13352 = CARTESIAN_POINT('',(0.,0.)); +#13353 = VECTOR('',#13354,1.); +#13354 = DIRECTION('',(-1.,-4.268150845686E-30)); +#13355 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13356 = ORIENTED_EDGE('',*,*,#3910,.F.); +#13357 = FACE_BOUND('',#13358,.T.); +#13358 = EDGE_LOOP('',(#13359)); +#13359 = ORIENTED_EDGE('',*,*,#10883,.T.); +#13360 = ADVANCED_FACE('',(#13361),#13375,.F.); +#13361 = FACE_BOUND('',#13362,.F.); +#13362 = EDGE_LOOP('',(#13363,#13393,#13424,#13425)); +#13363 = ORIENTED_EDGE('',*,*,#13364,.T.); +#13364 = EDGE_CURVE('',#13365,#13367,#13369,.T.); +#13365 = VERTEX_POINT('',#13366); +#13366 = CARTESIAN_POINT('',(22.000000000023,1.450000000001, + 9.500000000004)); +#13367 = VERTEX_POINT('',#13368); +#13368 = CARTESIAN_POINT('',(27.000000000023,1.450000000001, + 9.500000000004)); +#13369 = SEAM_CURVE('',#13370,(#13374,#13386),.PCURVE_S1.); +#13370 = LINE('',#13371,#13372); +#13371 = CARTESIAN_POINT('',(27.000000000023,1.450000000001, + 9.500000000004)); +#13372 = VECTOR('',#13373,1.); +#13373 = DIRECTION('',(1.,2.442490654175E-15,-6.646377858754E-29)); +#13374 = PCURVE('',#13375,#13380); +#13375 = CYLINDRICAL_SURFACE('',#13376,1.05); +#13376 = AXIS2_PLACEMENT_3D('',#13377,#13378,#13379); +#13377 = CARTESIAN_POINT('',(27.000000000023,0.400000000001, + 9.500000000004)); +#13378 = DIRECTION('',(-1.,-2.442490654175E-15,6.646377858754E-29)); +#13379 = DIRECTION('',(2.442490654175E-15,-1.,1.224646799147E-16)); +#13380 = DEFINITIONAL_REPRESENTATION('',(#13381),#13385); +#13381 = LINE('',#13382,#13383); +#13382 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13383 = VECTOR('',#13384,1.); +#13384 = DIRECTION('',(0.,-1.)); +#13385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13386 = PCURVE('',#13375,#13387); +#13387 = DEFINITIONAL_REPRESENTATION('',(#13388),#13392); +#13388 = LINE('',#13389,#13390); +#13389 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13390 = VECTOR('',#13391,1.); +#13391 = DIRECTION('',(0.,-1.)); +#13392 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13393 = ORIENTED_EDGE('',*,*,#13394,.T.); +#13394 = EDGE_CURVE('',#13367,#13367,#13395,.T.); +#13395 = SURFACE_CURVE('',#13396,(#13401,#13408),.PCURVE_S1.); +#13396 = CIRCLE('',#13397,1.05); +#13397 = AXIS2_PLACEMENT_3D('',#13398,#13399,#13400); +#13398 = CARTESIAN_POINT('',(27.000000000023,0.400000000001, + 9.500000000004)); +#13399 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13400 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13401 = PCURVE('',#13375,#13402); +#13402 = DEFINITIONAL_REPRESENTATION('',(#13403),#13407); +#13403 = LINE('',#13404,#13405); +#13404 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13405 = VECTOR('',#13406,1.); +#13406 = DIRECTION('',(1.,0.)); +#13407 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13408 = PCURVE('',#13409,#13414); +#13409 = PLANE('',#13410); +#13410 = AXIS2_PLACEMENT_3D('',#13411,#13412,#13413); +#13411 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13412 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13413 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13414 = DEFINITIONAL_REPRESENTATION('',(#13415),#13423); +#13415 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13416,#13417,#13418,#13419 + ,#13420,#13421,#13422),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13416 = CARTESIAN_POINT('',(63.95,5.000000000004)); +#13417 = CARTESIAN_POINT('',(63.95,6.818653347951)); +#13418 = CARTESIAN_POINT('',(65.525,5.909326673977)); +#13419 = CARTESIAN_POINT('',(67.1,5.000000000004)); +#13420 = CARTESIAN_POINT('',(65.525,4.09067332603)); +#13421 = CARTESIAN_POINT('',(63.95,3.181346652056)); +#13422 = CARTESIAN_POINT('',(63.95,5.000000000004)); +#13423 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13424 = ORIENTED_EDGE('',*,*,#13364,.F.); +#13425 = ORIENTED_EDGE('',*,*,#13426,.T.); +#13426 = EDGE_CURVE('',#13365,#13365,#13427,.T.); +#13427 = SURFACE_CURVE('',#13428,(#13433,#13440),.PCURVE_S1.); +#13428 = CIRCLE('',#13429,1.05); +#13429 = AXIS2_PLACEMENT_3D('',#13430,#13431,#13432); +#13430 = CARTESIAN_POINT('',(22.000000000023,0.400000000001, + 9.500000000004)); +#13431 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13432 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13433 = PCURVE('',#13375,#13434); +#13434 = DEFINITIONAL_REPRESENTATION('',(#13435),#13439); +#13435 = LINE('',#13436,#13437); +#13436 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13437 = VECTOR('',#13438,1.); +#13438 = DIRECTION('',(-1.,0.)); +#13439 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13440 = PCURVE('',#3982,#13441); +#13441 = DEFINITIONAL_REPRESENTATION('',(#13442),#13450); +#13442 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13443,#13444,#13445,#13446 + ,#13447,#13448,#13449),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13443 = CARTESIAN_POINT('',(1.05,-10.99999999999)); +#13444 = CARTESIAN_POINT('',(1.05,-12.81865334794)); +#13445 = CARTESIAN_POINT('',(-0.525,-11.90932667397)); +#13446 = CARTESIAN_POINT('',(-2.1,-10.99999999999)); +#13447 = CARTESIAN_POINT('',(-0.525,-10.09067332602)); +#13448 = CARTESIAN_POINT('',(1.05,-9.181346652049)); +#13449 = CARTESIAN_POINT('',(1.05,-10.99999999999)); +#13450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13451 = ADVANCED_FACE('',(#13452),#13466,.F.); +#13452 = FACE_BOUND('',#13453,.F.); +#13453 = EDGE_LOOP('',(#13454,#13484,#13515,#13516)); +#13454 = ORIENTED_EDGE('',*,*,#13455,.T.); +#13455 = EDGE_CURVE('',#13456,#13458,#13460,.T.); +#13456 = VERTEX_POINT('',#13457); +#13457 = CARTESIAN_POINT('',(22.000000000023,1.450000000001, + 28.800000000004)); +#13458 = VERTEX_POINT('',#13459); +#13459 = CARTESIAN_POINT('',(27.000000000023,1.450000000001, + 28.800000000004)); +#13460 = SEAM_CURVE('',#13461,(#13465,#13477),.PCURVE_S1.); +#13461 = LINE('',#13462,#13463); +#13462 = CARTESIAN_POINT('',(27.000000000023,1.450000000001, + 28.800000000004)); +#13463 = VECTOR('',#13464,1.); +#13464 = DIRECTION('',(1.,2.442490654175E-15,-6.646377858754E-29)); +#13465 = PCURVE('',#13466,#13471); +#13466 = CYLINDRICAL_SURFACE('',#13467,1.05); +#13467 = AXIS2_PLACEMENT_3D('',#13468,#13469,#13470); +#13468 = CARTESIAN_POINT('',(27.000000000023,0.400000000001, + 28.800000000004)); +#13469 = DIRECTION('',(-1.,-2.442490654175E-15,6.646377858754E-29)); +#13470 = DIRECTION('',(2.442490654175E-15,-1.,1.224646799147E-16)); +#13471 = DEFINITIONAL_REPRESENTATION('',(#13472),#13476); +#13472 = LINE('',#13473,#13474); +#13473 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13474 = VECTOR('',#13475,1.); +#13475 = DIRECTION('',(0.,-1.)); +#13476 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13477 = PCURVE('',#13466,#13478); +#13478 = DEFINITIONAL_REPRESENTATION('',(#13479),#13483); +#13479 = LINE('',#13480,#13481); +#13480 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13481 = VECTOR('',#13482,1.); +#13482 = DIRECTION('',(0.,-1.)); +#13483 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13484 = ORIENTED_EDGE('',*,*,#13485,.T.); +#13485 = EDGE_CURVE('',#13458,#13458,#13486,.T.); +#13486 = SURFACE_CURVE('',#13487,(#13492,#13499),.PCURVE_S1.); +#13487 = CIRCLE('',#13488,1.05); +#13488 = AXIS2_PLACEMENT_3D('',#13489,#13490,#13491); +#13489 = CARTESIAN_POINT('',(27.000000000023,0.400000000001, + 28.800000000004)); +#13490 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13491 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13492 = PCURVE('',#13466,#13493); +#13493 = DEFINITIONAL_REPRESENTATION('',(#13494),#13498); +#13494 = LINE('',#13495,#13496); +#13495 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13496 = VECTOR('',#13497,1.); +#13497 = DIRECTION('',(1.,0.)); +#13498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13499 = PCURVE('',#13500,#13505); +#13500 = PLANE('',#13501); +#13501 = AXIS2_PLACEMENT_3D('',#13502,#13503,#13504); +#13502 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13503 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13504 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13505 = DEFINITIONAL_REPRESENTATION('',(#13506),#13514); +#13506 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13507,#13508,#13509,#13510 + ,#13511,#13512,#13513),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13507 = CARTESIAN_POINT('',(63.95,24.300000000004)); +#13508 = CARTESIAN_POINT('',(63.95,26.118653347951)); +#13509 = CARTESIAN_POINT('',(65.525,25.209326673978)); +#13510 = CARTESIAN_POINT('',(67.1,24.300000000004)); +#13511 = CARTESIAN_POINT('',(65.525,23.39067332603)); +#13512 = CARTESIAN_POINT('',(63.95,22.481346652057)); +#13513 = CARTESIAN_POINT('',(63.95,24.300000000004)); +#13514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13515 = ORIENTED_EDGE('',*,*,#13455,.F.); +#13516 = ORIENTED_EDGE('',*,*,#13517,.T.); +#13517 = EDGE_CURVE('',#13456,#13456,#13518,.T.); +#13518 = SURFACE_CURVE('',#13519,(#13524,#13531),.PCURVE_S1.); +#13519 = CIRCLE('',#13520,1.05); +#13520 = AXIS2_PLACEMENT_3D('',#13521,#13522,#13523); +#13521 = CARTESIAN_POINT('',(22.000000000023,0.400000000001, + 28.800000000004)); +#13522 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13523 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13524 = PCURVE('',#13466,#13525); +#13525 = DEFINITIONAL_REPRESENTATION('',(#13526),#13530); +#13526 = LINE('',#13527,#13528); +#13527 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13528 = VECTOR('',#13529,1.); +#13529 = DIRECTION('',(-1.,0.)); +#13530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13531 = PCURVE('',#3982,#13532); +#13532 = DEFINITIONAL_REPRESENTATION('',(#13533),#13541); +#13533 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13534,#13535,#13536,#13537 + ,#13538,#13539,#13540),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13534 = CARTESIAN_POINT('',(1.05,8.300000000004)); +#13535 = CARTESIAN_POINT('',(1.05,6.481346652056)); +#13536 = CARTESIAN_POINT('',(-0.525,7.39067332603)); +#13537 = CARTESIAN_POINT('',(-2.1,8.300000000004)); +#13538 = CARTESIAN_POINT('',(-0.525,9.209326673977)); +#13539 = CARTESIAN_POINT('',(1.05,10.118653347951)); +#13540 = CARTESIAN_POINT('',(1.05,8.300000000004)); +#13541 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13542 = ADVANCED_FACE('',(#13543),#4010,.T.); +#13543 = FACE_BOUND('',#13544,.T.); +#13544 = EDGE_LOOP('',(#13545,#13566,#13567,#13588)); +#13545 = ORIENTED_EDGE('',*,*,#13546,.F.); +#13546 = EDGE_CURVE('',#3995,#12418,#13547,.T.); +#13547 = SURFACE_CURVE('',#13548,(#13552,#13559),.PCURVE_S1.); +#13548 = LINE('',#13549,#13550); +#13549 = CARTESIAN_POINT('',(27.000000000023,3.400000000001,20.5)); +#13550 = VECTOR('',#13551,1.); +#13551 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#13552 = PCURVE('',#4010,#13553); +#13553 = DEFINITIONAL_REPRESENTATION('',(#13554),#13558); +#13554 = LINE('',#13555,#13556); +#13555 = CARTESIAN_POINT('',(16.,-2.186041545893E-27)); +#13556 = VECTOR('',#13557,1.); +#13557 = DIRECTION('',(-1.,4.270329215564E-30)); +#13558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13559 = PCURVE('',#4038,#13560); +#13560 = DEFINITIONAL_REPRESENTATION('',(#13561),#13565); +#13561 = LINE('',#13562,#13563); +#13562 = CARTESIAN_POINT('',(68.,16.)); +#13563 = VECTOR('',#13564,1.); +#13564 = DIRECTION('',(0.,1.)); +#13565 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13566 = ORIENTED_EDGE('',*,*,#3994,.T.); +#13567 = ORIENTED_EDGE('',*,*,#13568,.F.); +#13568 = EDGE_CURVE('',#12441,#3967,#13569,.T.); +#13569 = SURFACE_CURVE('',#13570,(#13574,#13581),.PCURVE_S1.); +#13570 = LINE('',#13571,#13572); +#13571 = CARTESIAN_POINT('',(22.000000000023,3.400000000001,36.5)); +#13572 = VECTOR('',#13573,1.); +#13573 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#13574 = PCURVE('',#4010,#13575); +#13575 = DEFINITIONAL_REPRESENTATION('',(#13576),#13580); +#13576 = LINE('',#13577,#13578); +#13577 = CARTESIAN_POINT('',(6.84466645151E-28,5.)); +#13578 = VECTOR('',#13579,1.); +#13579 = DIRECTION('',(1.,0.)); +#13580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13581 = PCURVE('',#3982,#13582); +#13582 = DEFINITIONAL_REPRESENTATION('',(#13583),#13587); +#13583 = LINE('',#13584,#13585); +#13584 = CARTESIAN_POINT('',(-3.,16.)); +#13585 = VECTOR('',#13586,1.); +#13586 = DIRECTION('',(0.,-1.)); +#13587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13588 = ORIENTED_EDGE('',*,*,#12440,.F.); +#13589 = ADVANCED_FACE('',(#13590),#3954,.T.); +#13590 = FACE_BOUND('',#13591,.T.); +#13591 = EDGE_LOOP('',(#13592,#13593,#13594,#13615)); +#13592 = ORIENTED_EDGE('',*,*,#13336,.F.); +#13593 = ORIENTED_EDGE('',*,*,#12486,.F.); +#13594 = ORIENTED_EDGE('',*,*,#13595,.F.); +#13595 = EDGE_CURVE('',#3939,#12464,#13596,.T.); +#13596 = SURFACE_CURVE('',#13597,(#13601,#13608),.PCURVE_S1.); +#13597 = LINE('',#13598,#13599); +#13598 = CARTESIAN_POINT('',(22.000000000023,-2.599999999999,4.5)); +#13599 = VECTOR('',#13600,1.); +#13600 = DIRECTION('',(7.060453438158E-29,5.307574087566E-17,1.)); +#13601 = PCURVE('',#3954,#13602); +#13602 = DEFINITIONAL_REPRESENTATION('',(#13603),#13607); +#13603 = LINE('',#13604,#13605); +#13604 = CARTESIAN_POINT('',(-6.844823704882E-28,5.)); +#13605 = VECTOR('',#13606,1.); +#13606 = DIRECTION('',(1.,0.)); +#13607 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13608 = PCURVE('',#3982,#13609); +#13609 = DEFINITIONAL_REPRESENTATION('',(#13610),#13614); +#13610 = LINE('',#13611,#13612); +#13611 = CARTESIAN_POINT('',(3.,-16.)); +#13612 = VECTOR('',#13613,1.); +#13613 = DIRECTION('',(6.938893903907E-17,1.)); +#13614 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13615 = ORIENTED_EDGE('',*,*,#3938,.F.); +#13616 = ADVANCED_FACE('',(#13617,#13623,#13626),#3982,.T.); +#13617 = FACE_BOUND('',#13618,.T.); +#13618 = EDGE_LOOP('',(#13619,#13620,#13621,#13622)); +#13619 = ORIENTED_EDGE('',*,*,#13595,.T.); +#13620 = ORIENTED_EDGE('',*,*,#12463,.F.); +#13621 = ORIENTED_EDGE('',*,*,#13568,.T.); +#13622 = ORIENTED_EDGE('',*,*,#3966,.T.); +#13623 = FACE_BOUND('',#13624,.T.); +#13624 = EDGE_LOOP('',(#13625)); +#13625 = ORIENTED_EDGE('',*,*,#13517,.T.); +#13626 = FACE_BOUND('',#13627,.T.); +#13627 = EDGE_LOOP('',(#13628)); +#13628 = ORIENTED_EDGE('',*,*,#13426,.T.); +#13629 = ADVANCED_FACE('',(#13630),#13500,.F.); +#13630 = FACE_BOUND('',#13631,.T.); +#13631 = EDGE_LOOP('',(#13632)); +#13632 = ORIENTED_EDGE('',*,*,#13485,.T.); +#13633 = ADVANCED_FACE('',(#13634),#4038,.F.); +#13634 = FACE_BOUND('',#13635,.T.); +#13635 = EDGE_LOOP('',(#13636,#13637,#13638,#13659)); +#13636 = ORIENTED_EDGE('',*,*,#13546,.T.); +#13637 = ORIENTED_EDGE('',*,*,#12417,.F.); +#13638 = ORIENTED_EDGE('',*,*,#13639,.T.); +#13639 = EDGE_CURVE('',#12395,#4023,#13640,.T.); +#13640 = SURFACE_CURVE('',#13641,(#13645,#13652),.PCURVE_S1.); +#13641 = LINE('',#13642,#13643); +#13642 = CARTESIAN_POINT('',(27.000000000023,13.400000000001,4.5)); +#13643 = VECTOR('',#13644,1.); +#13644 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#13645 = PCURVE('',#4038,#13646); +#13646 = DEFINITIONAL_REPRESENTATION('',(#13647),#13651); +#13647 = LINE('',#13648,#13649); +#13648 = CARTESIAN_POINT('',(78.,-4.658609681853E-15)); +#13649 = VECTOR('',#13650,1.); +#13650 = DIRECTION('',(0.,-1.)); +#13651 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13652 = PCURVE('',#4066,#13653); +#13653 = DEFINITIONAL_REPRESENTATION('',(#13654),#13658); +#13654 = LINE('',#13655,#13656); +#13655 = CARTESIAN_POINT('',(0.,0.)); +#13656 = VECTOR('',#13657,1.); +#13657 = DIRECTION('',(-1.,-4.270329215564E-30)); +#13658 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13659 = ORIENTED_EDGE('',*,*,#4022,.F.); +#13660 = ADVANCED_FACE('',(#13661),#13409,.F.); +#13661 = FACE_BOUND('',#13662,.T.); +#13662 = EDGE_LOOP('',(#13663)); +#13663 = ORIENTED_EDGE('',*,*,#13394,.T.); +#13664 = ADVANCED_FACE('',(#13665),#13679,.F.); +#13665 = FACE_BOUND('',#13666,.F.); +#13666 = EDGE_LOOP('',(#13667,#13697,#13728,#13729)); +#13667 = ORIENTED_EDGE('',*,*,#13668,.T.); +#13668 = EDGE_CURVE('',#13669,#13671,#13673,.T.); +#13669 = VERTEX_POINT('',#13670); +#13670 = CARTESIAN_POINT('',(22.000000000023,17.450000000001, + 9.500000000005)); +#13671 = VERTEX_POINT('',#13672); +#13672 = CARTESIAN_POINT('',(27.000000000023,17.450000000001, + 9.500000000005)); +#13673 = SEAM_CURVE('',#13674,(#13678,#13690),.PCURVE_S1.); +#13674 = LINE('',#13675,#13676); +#13675 = CARTESIAN_POINT('',(27.000000000023,17.450000000001, + 9.500000000005)); +#13676 = VECTOR('',#13677,1.); +#13677 = DIRECTION('',(1.,2.6645352591E-15,-6.649097120901E-29)); +#13678 = PCURVE('',#13679,#13684); +#13679 = CYLINDRICAL_SURFACE('',#13680,1.05); +#13680 = AXIS2_PLACEMENT_3D('',#13681,#13682,#13683); +#13681 = CARTESIAN_POINT('',(27.000000000023,16.400000000001, + 9.500000000005)); +#13682 = DIRECTION('',(-1.,-2.6645352591E-15,6.649097120901E-29)); +#13683 = DIRECTION('',(2.6645352591E-15,-1.,1.224646799147E-16)); +#13684 = DEFINITIONAL_REPRESENTATION('',(#13685),#13689); +#13685 = LINE('',#13686,#13687); +#13686 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13687 = VECTOR('',#13688,1.); +#13688 = DIRECTION('',(0.,-1.)); +#13689 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13690 = PCURVE('',#13679,#13691); +#13691 = DEFINITIONAL_REPRESENTATION('',(#13692),#13696); +#13692 = LINE('',#13693,#13694); +#13693 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13694 = VECTOR('',#13695,1.); +#13695 = DIRECTION('',(0.,-1.)); +#13696 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13697 = ORIENTED_EDGE('',*,*,#13698,.T.); +#13698 = EDGE_CURVE('',#13671,#13671,#13699,.T.); +#13699 = SURFACE_CURVE('',#13700,(#13705,#13712),.PCURVE_S1.); +#13700 = CIRCLE('',#13701,1.05); +#13701 = AXIS2_PLACEMENT_3D('',#13702,#13703,#13704); +#13702 = CARTESIAN_POINT('',(27.000000000023,16.400000000001, + 9.500000000005)); +#13703 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13704 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13705 = PCURVE('',#13679,#13706); +#13706 = DEFINITIONAL_REPRESENTATION('',(#13707),#13711); +#13707 = LINE('',#13708,#13709); +#13708 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13709 = VECTOR('',#13710,1.); +#13710 = DIRECTION('',(1.,0.)); +#13711 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13712 = PCURVE('',#13713,#13718); +#13713 = PLANE('',#13714); +#13714 = AXIS2_PLACEMENT_3D('',#13715,#13716,#13717); +#13715 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13716 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13717 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13718 = DEFINITIONAL_REPRESENTATION('',(#13719),#13727); +#13719 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13720,#13721,#13722,#13723 + ,#13724,#13725,#13726),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13720 = CARTESIAN_POINT('',(79.95,5.000000000005)); +#13721 = CARTESIAN_POINT('',(79.95,6.818653347952)); +#13722 = CARTESIAN_POINT('',(81.525,5.909326673978)); +#13723 = CARTESIAN_POINT('',(83.1,5.000000000005)); +#13724 = CARTESIAN_POINT('',(81.525,4.090673326031)); +#13725 = CARTESIAN_POINT('',(79.95,3.181346652057)); +#13726 = CARTESIAN_POINT('',(79.95,5.000000000005)); +#13727 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13728 = ORIENTED_EDGE('',*,*,#13668,.F.); +#13729 = ORIENTED_EDGE('',*,*,#13730,.T.); +#13730 = EDGE_CURVE('',#13669,#13669,#13731,.T.); +#13731 = SURFACE_CURVE('',#13732,(#13737,#13744),.PCURVE_S1.); +#13732 = CIRCLE('',#13733,1.05); +#13733 = AXIS2_PLACEMENT_3D('',#13734,#13735,#13736); +#13734 = CARTESIAN_POINT('',(22.000000000023,16.400000000001, + 9.500000000005)); +#13735 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13736 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13737 = PCURVE('',#13679,#13738); +#13738 = DEFINITIONAL_REPRESENTATION('',(#13739),#13743); +#13739 = LINE('',#13740,#13741); +#13740 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13741 = VECTOR('',#13742,1.); +#13742 = DIRECTION('',(-1.,0.)); +#13743 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13744 = PCURVE('',#4094,#13745); +#13745 = DEFINITIONAL_REPRESENTATION('',(#13746),#13754); +#13746 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13747,#13748,#13749,#13750 + ,#13751,#13752,#13753),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13747 = CARTESIAN_POINT('',(1.05,-10.99999999999)); +#13748 = CARTESIAN_POINT('',(1.05,-12.81865334794)); +#13749 = CARTESIAN_POINT('',(-0.525,-11.90932667396)); +#13750 = CARTESIAN_POINT('',(-2.1,-10.99999999999)); +#13751 = CARTESIAN_POINT('',(-0.525,-10.09067332602)); +#13752 = CARTESIAN_POINT('',(1.05,-9.181346652048)); +#13753 = CARTESIAN_POINT('',(1.05,-10.99999999999)); +#13754 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13755 = ADVANCED_FACE('',(#13756),#13770,.F.); +#13756 = FACE_BOUND('',#13757,.F.); +#13757 = EDGE_LOOP('',(#13758,#13788,#13819,#13820)); +#13758 = ORIENTED_EDGE('',*,*,#13759,.T.); +#13759 = EDGE_CURVE('',#13760,#13762,#13764,.T.); +#13760 = VERTEX_POINT('',#13761); +#13761 = CARTESIAN_POINT('',(22.000000000023,17.450000000001, + 22.300000000005)); +#13762 = VERTEX_POINT('',#13763); +#13763 = CARTESIAN_POINT('',(27.000000000023,17.450000000001, + 22.300000000005)); +#13764 = SEAM_CURVE('',#13765,(#13769,#13781),.PCURVE_S1.); +#13765 = LINE('',#13766,#13767); +#13766 = CARTESIAN_POINT('',(27.000000000023,17.450000000001, + 22.300000000005)); +#13767 = VECTOR('',#13768,1.); +#13768 = DIRECTION('',(1.,2.6645352591E-15,-6.649097120901E-29)); +#13769 = PCURVE('',#13770,#13775); +#13770 = CYLINDRICAL_SURFACE('',#13771,1.05); +#13771 = AXIS2_PLACEMENT_3D('',#13772,#13773,#13774); +#13772 = CARTESIAN_POINT('',(27.000000000023,16.400000000001, + 22.300000000005)); +#13773 = DIRECTION('',(-1.,-2.6645352591E-15,6.649097120901E-29)); +#13774 = DIRECTION('',(2.6645352591E-15,-1.,1.224646799147E-16)); +#13775 = DEFINITIONAL_REPRESENTATION('',(#13776),#13780); +#13776 = LINE('',#13777,#13778); +#13777 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#13778 = VECTOR('',#13779,1.); +#13779 = DIRECTION('',(0.,-1.)); +#13780 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13781 = PCURVE('',#13770,#13782); +#13782 = DEFINITIONAL_REPRESENTATION('',(#13783),#13787); +#13783 = LINE('',#13784,#13785); +#13784 = CARTESIAN_POINT('',(3.14159265359,0.)); +#13785 = VECTOR('',#13786,1.); +#13786 = DIRECTION('',(0.,-1.)); +#13787 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13788 = ORIENTED_EDGE('',*,*,#13789,.T.); +#13789 = EDGE_CURVE('',#13762,#13762,#13790,.T.); +#13790 = SURFACE_CURVE('',#13791,(#13796,#13803),.PCURVE_S1.); +#13791 = CIRCLE('',#13792,1.05); +#13792 = AXIS2_PLACEMENT_3D('',#13793,#13794,#13795); +#13793 = CARTESIAN_POINT('',(27.000000000023,16.400000000001, + 22.300000000005)); +#13794 = DIRECTION('',(-1.,-2.474800550248E-15,6.646773540862E-29)); +#13795 = DIRECTION('',(2.474800550248E-15,-1.,1.224646799147E-16)); +#13796 = PCURVE('',#13770,#13797); +#13797 = DEFINITIONAL_REPRESENTATION('',(#13798),#13802); +#13798 = LINE('',#13799,#13800); +#13799 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#13800 = VECTOR('',#13801,1.); +#13801 = DIRECTION('',(1.,0.)); +#13802 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13803 = PCURVE('',#13804,#13809); +#13804 = PLANE('',#13805); +#13805 = AXIS2_PLACEMENT_3D('',#13806,#13807,#13808); +#13806 = CARTESIAN_POINT('',(27.000000000023,-64.59999999999,4.5)); +#13807 = DIRECTION('',(1.,2.474800550248E-15,-6.646773540862E-29)); +#13808 = DIRECTION('',(-2.474800550248E-15,1.,-1.224646799147E-16)); +#13809 = DEFINITIONAL_REPRESENTATION('',(#13810),#13818); +#13810 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13811,#13812,#13813,#13814 + ,#13815,#13816,#13817),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13811 = CARTESIAN_POINT('',(79.95,17.800000000005)); +#13812 = CARTESIAN_POINT('',(79.95,19.618653347952)); +#13813 = CARTESIAN_POINT('',(81.525,18.709326673978)); +#13814 = CARTESIAN_POINT('',(83.1,17.800000000005)); +#13815 = CARTESIAN_POINT('',(81.525,16.890673326031)); +#13816 = CARTESIAN_POINT('',(79.95,15.981346652057)); +#13817 = CARTESIAN_POINT('',(79.95,17.800000000005)); +#13818 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13819 = ORIENTED_EDGE('',*,*,#13759,.F.); +#13820 = ORIENTED_EDGE('',*,*,#13821,.T.); +#13821 = EDGE_CURVE('',#13760,#13760,#13822,.T.); +#13822 = SURFACE_CURVE('',#13823,(#13828,#13835),.PCURVE_S1.); +#13823 = CIRCLE('',#13824,1.05); +#13824 = AXIS2_PLACEMENT_3D('',#13825,#13826,#13827); +#13825 = CARTESIAN_POINT('',(22.000000000023,16.400000000001, + 22.300000000005)); +#13826 = DIRECTION('',(1.,2.443406931777E-15,-7.073422001475E-29)); +#13827 = DIRECTION('',(2.443406931777E-15,-1.,1.224646799147E-16)); +#13828 = PCURVE('',#13770,#13829); +#13829 = DEFINITIONAL_REPRESENTATION('',(#13830),#13834); +#13830 = LINE('',#13831,#13832); +#13831 = CARTESIAN_POINT('',(6.28318530718,5.)); +#13832 = VECTOR('',#13833,1.); +#13833 = DIRECTION('',(-1.,0.)); +#13834 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13835 = PCURVE('',#4094,#13836); +#13836 = DEFINITIONAL_REPRESENTATION('',(#13837),#13845); +#13837 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#13838,#13839,#13840,#13841 + ,#13842,#13843,#13844),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#13838 = CARTESIAN_POINT('',(1.05,1.800000000004)); +#13839 = CARTESIAN_POINT('',(1.05,-1.865334794283E-02)); +#13840 = CARTESIAN_POINT('',(-0.525,0.890673326031)); +#13841 = CARTESIAN_POINT('',(-2.1,1.800000000004)); +#13842 = CARTESIAN_POINT('',(-0.525,2.709326673978)); +#13843 = CARTESIAN_POINT('',(1.05,3.618653347952)); +#13844 = CARTESIAN_POINT('',(1.05,1.800000000004)); +#13845 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13846 = ADVANCED_FACE('',(#13847),#4122,.T.); +#13847 = FACE_BOUND('',#13848,.T.); +#13848 = EDGE_LOOP('',(#13849,#13870,#13871,#13892)); +#13849 = ORIENTED_EDGE('',*,*,#13850,.F.); +#13850 = EDGE_CURVE('',#4107,#12326,#13851,.T.); +#13851 = SURFACE_CURVE('',#13852,(#13856,#13863),.PCURVE_S1.); +#13852 = LINE('',#13853,#13854); +#13853 = CARTESIAN_POINT('',(27.000000000023,19.400000000001,20.5)); +#13854 = VECTOR('',#13855,1.); +#13855 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#13856 = PCURVE('',#4122,#13857); +#13857 = DEFINITIONAL_REPRESENTATION('',(#13858),#13862); +#13858 = LINE('',#13859,#13860); +#13859 = CARTESIAN_POINT('',(16.,-2.181349031953E-27)); +#13860 = VECTOR('',#13861,1.); +#13861 = DIRECTION('',(-1.,4.270329215564E-30)); +#13862 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13863 = PCURVE('',#4150,#13864); +#13864 = DEFINITIONAL_REPRESENTATION('',(#13865),#13869); +#13865 = LINE('',#13866,#13867); +#13866 = CARTESIAN_POINT('',(84.,16.)); +#13867 = VECTOR('',#13868,1.); +#13868 = DIRECTION('',(0.,1.)); +#13869 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13870 = ORIENTED_EDGE('',*,*,#4106,.T.); +#13871 = ORIENTED_EDGE('',*,*,#13872,.F.); +#13872 = EDGE_CURVE('',#12349,#4079,#13873,.T.); +#13873 = SURFACE_CURVE('',#13874,(#13878,#13885),.PCURVE_S1.); +#13874 = LINE('',#13875,#13876); +#13875 = CARTESIAN_POINT('',(22.000000000023,19.400000000001,36.5)); +#13876 = VECTOR('',#13877,1.); +#13877 = DIRECTION('',(-7.043498896695E-29,-1.224646799147E-16,-1.)); +#13878 = PCURVE('',#4122,#13879); +#13879 = DEFINITIONAL_REPRESENTATION('',(#13880),#13884); +#13880 = LINE('',#13881,#13882); +#13881 = CARTESIAN_POINT('',(6.847385713657E-28,5.)); +#13882 = VECTOR('',#13883,1.); +#13883 = DIRECTION('',(1.,0.)); +#13884 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13885 = PCURVE('',#4094,#13886); +#13886 = DEFINITIONAL_REPRESENTATION('',(#13887),#13891); +#13887 = LINE('',#13888,#13889); +#13888 = CARTESIAN_POINT('',(-3.,16.)); +#13889 = VECTOR('',#13890,1.); +#13890 = DIRECTION('',(0.,-1.)); +#13891 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13892 = ORIENTED_EDGE('',*,*,#12348,.F.); +#13893 = ADVANCED_FACE('',(#13894),#4066,.T.); +#13894 = FACE_BOUND('',#13895,.T.); +#13895 = EDGE_LOOP('',(#13896,#13897,#13898,#13919)); +#13896 = ORIENTED_EDGE('',*,*,#13639,.F.); +#13897 = ORIENTED_EDGE('',*,*,#12394,.F.); +#13898 = ORIENTED_EDGE('',*,*,#13899,.F.); +#13899 = EDGE_CURVE('',#4051,#12372,#13900,.T.); +#13900 = SURFACE_CURVE('',#13901,(#13905,#13912),.PCURVE_S1.); +#13901 = LINE('',#13902,#13903); +#13902 = CARTESIAN_POINT('',(22.000000000023,13.400000000001,4.5)); +#13903 = VECTOR('',#13904,1.); +#13904 = DIRECTION('',(7.043498896695E-29,1.224646799147E-16,1.)); +#13905 = PCURVE('',#4066,#13906); +#13906 = DEFINITIONAL_REPRESENTATION('',(#13907),#13911); +#13907 = LINE('',#13908,#13909); +#13908 = CARTESIAN_POINT('',(-6.847385713657E-28,5.)); +#13909 = VECTOR('',#13910,1.); +#13910 = DIRECTION('',(1.,0.)); +#13911 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13912 = PCURVE('',#4094,#13913); +#13913 = DEFINITIONAL_REPRESENTATION('',(#13914),#13918); +#13914 = LINE('',#13915,#13916); +#13915 = CARTESIAN_POINT('',(3.,-16.)); +#13916 = VECTOR('',#13917,1.); +#13917 = DIRECTION('',(0.,1.)); +#13918 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13919 = ORIENTED_EDGE('',*,*,#4050,.F.); +#13920 = ADVANCED_FACE('',(#13921,#13927,#13930),#4094,.T.); +#13921 = FACE_BOUND('',#13922,.T.); +#13922 = EDGE_LOOP('',(#13923,#13924,#13925,#13926)); +#13923 = ORIENTED_EDGE('',*,*,#13899,.T.); +#13924 = ORIENTED_EDGE('',*,*,#12371,.F.); +#13925 = ORIENTED_EDGE('',*,*,#13872,.T.); +#13926 = ORIENTED_EDGE('',*,*,#4078,.T.); +#13927 = FACE_BOUND('',#13928,.T.); +#13928 = EDGE_LOOP('',(#13929)); +#13929 = ORIENTED_EDGE('',*,*,#13821,.T.); +#13930 = FACE_BOUND('',#13931,.T.); +#13931 = EDGE_LOOP('',(#13932)); +#13932 = ORIENTED_EDGE('',*,*,#13730,.T.); +#13933 = ADVANCED_FACE('',(#13934),#13804,.F.); +#13934 = FACE_BOUND('',#13935,.T.); +#13935 = EDGE_LOOP('',(#13936)); +#13936 = ORIENTED_EDGE('',*,*,#13789,.T.); +#13937 = ADVANCED_FACE('',(#13938),#13154,.F.); +#13938 = FACE_BOUND('',#13939,.T.); +#13939 = EDGE_LOOP('',(#13940)); +#13940 = ORIENTED_EDGE('',*,*,#13139,.T.); +#13941 = ADVANCED_FACE('',(#13942),#13713,.F.); +#13942 = FACE_BOUND('',#13943,.T.); +#13943 = EDGE_LOOP('',(#13944)); +#13944 = ORIENTED_EDGE('',*,*,#13698,.T.); +#13945 = ADVANCED_FACE('',(#13946),#4687,.F.); +#13946 = FACE_BOUND('',#13947,.T.); +#13947 = EDGE_LOOP('',(#13948,#13949,#13950,#13951)); +#13948 = ORIENTED_EDGE('',*,*,#5433,.T.); +#13949 = ORIENTED_EDGE('',*,*,#5752,.T.); +#13950 = ORIENTED_EDGE('',*,*,#4671,.T.); +#13951 = ORIENTED_EDGE('',*,*,#5582,.T.); +#13952 = ADVANCED_FACE('',(#13953),#13967,.F.); +#13953 = FACE_BOUND('',#13954,.F.); +#13954 = EDGE_LOOP('',(#13955,#13990,#14018,#14046)); +#13955 = ORIENTED_EDGE('',*,*,#13956,.F.); +#13956 = EDGE_CURVE('',#13957,#13959,#13961,.T.); +#13957 = VERTEX_POINT('',#13958); +#13958 = CARTESIAN_POINT('',(-32.99999999994,-53.34999999999,16.85)); +#13959 = VERTEX_POINT('',#13960); +#13960 = CARTESIAN_POINT('',(-27.49999999994,-53.34999999999,16.85)); +#13961 = SURFACE_CURVE('',#13962,(#13966,#13978),.PCURVE_S1.); +#13962 = LINE('',#13963,#13964); +#13963 = CARTESIAN_POINT('',(-25.49999999994,-53.34999999999,16.85)); +#13964 = VECTOR('',#13965,1.); +#13965 = DIRECTION('',(1.,4.864065825301E-15,-6.676033601576E-29)); +#13966 = PCURVE('',#13967,#13972); +#13967 = CYLINDRICAL_SURFACE('',#13968,1.1); +#13968 = AXIS2_PLACEMENT_3D('',#13969,#13970,#13971); +#13969 = CARTESIAN_POINT('',(-25.49999999994,-52.24999999999,16.85)); +#13970 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#13971 = DIRECTION('',(3.439413929208E-15,-0.707106781187, + -0.707106781187)); +#13972 = DEFINITIONAL_REPRESENTATION('',(#13973),#13977); +#13973 = LINE('',#13974,#13975); +#13974 = CARTESIAN_POINT('',(0.785398163397,3.552713678801E-15)); +#13975 = VECTOR('',#13976,1.); +#13976 = DIRECTION('',(8.276208001751E-16,-1.)); +#13977 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13978 = PCURVE('',#13979,#13984); +#13979 = PLANE('',#13980); +#13980 = AXIS2_PLACEMENT_3D('',#13981,#13982,#13983); +#13981 = CARTESIAN_POINT('',(-25.49999999994,-53.34999999999,15.75)); +#13982 = DIRECTION('',(4.864065825301E-15,-1.,1.992313984547E-15)); +#13983 = DIRECTION('',(5.710596993066E-29,1.992313984547E-15,1.)); +#13984 = DEFINITIONAL_REPRESENTATION('',(#13985),#13989); +#13985 = LINE('',#13986,#13987); +#13986 = CARTESIAN_POINT('',(1.1,1.462575136523E-28)); +#13987 = VECTOR('',#13988,1.); +#13988 = DIRECTION('',(3.63802804026E-32,-1.)); +#13989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#13990 = ORIENTED_EDGE('',*,*,#13991,.F.); +#13991 = EDGE_CURVE('',#13992,#13957,#13994,.T.); +#13992 = VERTEX_POINT('',#13993); +#13993 = CARTESIAN_POINT('',(-32.99999999994,-52.24999999999,15.75)); +#13994 = SURFACE_CURVE('',#13995,(#14000,#14007),.PCURVE_S1.); +#13995 = CIRCLE('',#13996,1.1); +#13996 = AXIS2_PLACEMENT_3D('',#13997,#13998,#13999); +#13997 = CARTESIAN_POINT('',(-32.99999999994,-52.24999999999,16.85)); +#13998 = DIRECTION('',(-1.,-6.704039033313E-15,6.81793225306E-29)); +#13999 = DIRECTION('',(4.740471461795E-15,-0.707106781187, + -0.707106781187)); +#14000 = PCURVE('',#13967,#14001); +#14001 = DEFINITIONAL_REPRESENTATION('',(#14002),#14006); +#14002 = LINE('',#14003,#14004); +#14003 = CARTESIAN_POINT('',(-6.28318530718,7.5)); +#14004 = VECTOR('',#14005,1.); +#14005 = DIRECTION('',(1.,-1.130863886743E-15)); +#14006 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14007 = PCURVE('',#3447,#14008); +#14008 = DEFINITIONAL_REPRESENTATION('',(#14009),#14017); +#14009 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14010,#14011,#14012,#14013 + ,#14014,#14015,#14016),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14010 = CARTESIAN_POINT('',(22.427817459305,11.57218254072)); +#14011 = CARTESIAN_POINT('',(21.080598100774,10.224963182189)); +#14012 = CARTESIAN_POINT('',(20.587481591082,12.065299050412)); +#14013 = CARTESIAN_POINT('',(20.09436508139,13.905634918635)); +#14014 = CARTESIAN_POINT('',(21.934700949613,13.412518408943)); +#14015 = CARTESIAN_POINT('',(23.775036817836,12.919401899251)); +#14016 = CARTESIAN_POINT('',(22.427817459305,11.57218254072)); +#14017 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14018 = ORIENTED_EDGE('',*,*,#14019,.F.); +#14019 = EDGE_CURVE('',#14020,#13992,#14022,.T.); +#14020 = VERTEX_POINT('',#14021); +#14021 = CARTESIAN_POINT('',(-27.49999999994,-52.24999999999,15.75)); +#14022 = SURFACE_CURVE('',#14023,(#14027,#14034),.PCURVE_S1.); +#14023 = LINE('',#14024,#14025); +#14024 = CARTESIAN_POINT('',(-25.49999999994,-52.24999999999,15.75)); +#14025 = VECTOR('',#14026,1.); +#14026 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14027 = PCURVE('',#13967,#14028); +#14028 = DEFINITIONAL_REPRESENTATION('',(#14029),#14033); +#14029 = LINE('',#14030,#14031); +#14030 = CARTESIAN_POINT('',(-0.785398163397,-1.7763568394E-15)); +#14031 = VECTOR('',#14032,1.); +#14032 = DIRECTION('',(2.5837917664E-15,1.)); +#14033 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14034 = PCURVE('',#14035,#14040); +#14035 = PLANE('',#14036); +#14036 = AXIS2_PLACEMENT_3D('',#14037,#14038,#14039); +#14037 = CARTESIAN_POINT('',(-25.49999999994,-49.84999999999,15.75)); +#14038 = DIRECTION('',(-4.147804090548E-29,-5.197769935344E-15,-1.)); +#14039 = DIRECTION('',(4.844609562001E-15,-1.,5.197769935344E-15)); +#14040 = DEFINITIONAL_REPRESENTATION('',(#14041),#14045); +#14041 = LINE('',#14042,#14043); +#14042 = CARTESIAN_POINT('',(2.4,1.16270629488E-14)); +#14043 = VECTOR('',#14044,1.); +#14044 = DIRECTION('',(1.945626330019E-17,1.)); +#14045 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14046 = ORIENTED_EDGE('',*,*,#14047,.F.); +#14047 = EDGE_CURVE('',#13959,#14020,#14048,.T.); +#14048 = SURFACE_CURVE('',#14049,(#14054,#14061),.PCURVE_S1.); +#14049 = CIRCLE('',#14050,1.1); +#14050 = AXIS2_PLACEMENT_3D('',#14051,#14052,#14053); +#14051 = CARTESIAN_POINT('',(-27.49999999994,-52.24999999999,16.85)); +#14052 = DIRECTION('',(1.,4.440892098501E-15,-6.657192021998E-29)); +#14053 = DIRECTION('',(3.140184917368E-15,-0.707106781187, + -0.707106781187)); +#14054 = PCURVE('',#13967,#14055); +#14055 = DEFINITIONAL_REPRESENTATION('',(#14056),#14060); +#14056 = LINE('',#14057,#14058); +#14057 = CARTESIAN_POINT('',(6.28318530718,2.)); +#14058 = VECTOR('',#14059,1.); +#14059 = DIRECTION('',(-1.,0.)); +#14060 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14061 = PCURVE('',#14062,#14067); +#14062 = PLANE('',#14063); +#14063 = AXIS2_PLACEMENT_3D('',#14064,#14065,#14066); +#14064 = CARTESIAN_POINT('',(-27.49999999994,-51.59999999999,20.5)); +#14065 = DIRECTION('',(-1.,-4.440892098501E-15,6.670851218076E-29)); +#14066 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#14067 = DEFINITIONAL_REPRESENTATION('',(#14068),#14076); +#14068 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14069,#14070,#14071,#14072 + ,#14073,#14074,#14075),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14069 = CARTESIAN_POINT('',(-4.427817459305,-1.427817459305)); +#14070 = CARTESIAN_POINT('',(-5.775036817836,-8.059810077446E-02)); +#14071 = CARTESIAN_POINT('',(-3.934700949613,0.412518408918)); +#14072 = CARTESIAN_POINT('',(-2.09436508139,0.90563491861)); +#14073 = CARTESIAN_POINT('',(-2.587481591082,-0.934700949613)); +#14074 = CARTESIAN_POINT('',(-3.080598100774,-2.775036817836)); +#14075 = CARTESIAN_POINT('',(-4.427817459305,-1.427817459305)); +#14076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14077 = ADVANCED_FACE('',(#14078),#14035,.F.); +#14078 = FACE_BOUND('',#14079,.T.); +#14079 = EDGE_LOOP('',(#14080,#14081,#14104,#14132)); +#14080 = ORIENTED_EDGE('',*,*,#14019,.F.); +#14081 = ORIENTED_EDGE('',*,*,#14082,.T.); +#14082 = EDGE_CURVE('',#14020,#14083,#14085,.T.); +#14083 = VERTEX_POINT('',#14084); +#14084 = CARTESIAN_POINT('',(-27.49999999994,-50.94999999999,15.75)); +#14085 = SURFACE_CURVE('',#14086,(#14090,#14097),.PCURVE_S1.); +#14086 = LINE('',#14087,#14088); +#14087 = CARTESIAN_POINT('',(-27.49999999994,-50.72499999999,15.75)); +#14088 = VECTOR('',#14089,1.); +#14089 = DIRECTION('',(-4.440892098501E-15,1.,-5.197769935344E-15)); +#14090 = PCURVE('',#14035,#14091); +#14091 = DEFINITIONAL_REPRESENTATION('',(#14092),#14096); +#14092 = LINE('',#14093,#14094); +#14093 = CARTESIAN_POINT('',(0.875,2.)); +#14094 = VECTOR('',#14095,1.); +#14095 = DIRECTION('',(-1.,-4.037174635001E-16)); +#14096 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14097 = PCURVE('',#14062,#14098); +#14098 = DEFINITIONAL_REPRESENTATION('',(#14099),#14103); +#14099 = LINE('',#14100,#14101); +#14100 = CARTESIAN_POINT('',(-4.75,0.875)); +#14101 = VECTOR('',#14102,1.); +#14102 = DIRECTION('',(-5.075305255429E-15,1.)); +#14103 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14104 = ORIENTED_EDGE('',*,*,#14105,.F.); +#14105 = EDGE_CURVE('',#14106,#14083,#14108,.T.); +#14106 = VERTEX_POINT('',#14107); +#14107 = CARTESIAN_POINT('',(-32.99999999994,-50.94999999999,15.75)); +#14108 = SURFACE_CURVE('',#14109,(#14113,#14120),.PCURVE_S1.); +#14109 = LINE('',#14110,#14111); +#14110 = CARTESIAN_POINT('',(-25.49999999994,-50.94999999999,15.75)); +#14111 = VECTOR('',#14112,1.); +#14112 = DIRECTION('',(1.,4.864065825301E-15,-6.676033601576E-29)); +#14113 = PCURVE('',#14035,#14114); +#14114 = DEFINITIONAL_REPRESENTATION('',(#14115),#14119); +#14115 = LINE('',#14116,#14117); +#14116 = CARTESIAN_POINT('',(1.1,5.329070518201E-15)); +#14117 = VECTOR('',#14118,1.); +#14118 = DIRECTION('',(-1.945626330019E-17,-1.)); +#14119 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14120 = PCURVE('',#14121,#14126); +#14121 = CYLINDRICAL_SURFACE('',#14122,1.1); +#14122 = AXIS2_PLACEMENT_3D('',#14123,#14124,#14125); +#14123 = CARTESIAN_POINT('',(-25.49999999994,-50.94999999999,16.85)); +#14124 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14125 = DIRECTION('',(-3.439413929208E-15,0.707106781187, + -0.707106781187)); +#14126 = DEFINITIONAL_REPRESENTATION('',(#14127),#14131); +#14127 = LINE('',#14128,#14129); +#14128 = CARTESIAN_POINT('',(0.785398163397,0.)); +#14129 = VECTOR('',#14130,1.); +#14130 = DIRECTION('',(-2.5030482737E-15,-1.)); +#14131 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14132 = ORIENTED_EDGE('',*,*,#14133,.F.); +#14133 = EDGE_CURVE('',#13992,#14106,#14134,.T.); +#14134 = SURFACE_CURVE('',#14135,(#14139,#14146),.PCURVE_S1.); +#14135 = LINE('',#14136,#14137); +#14136 = CARTESIAN_POINT('',(-32.99999999994,-44.22499999999,15.75)); +#14137 = VECTOR('',#14138,1.); +#14138 = DIRECTION('',(-6.704039033313E-15,1.,-5.197769935344E-15)); +#14139 = PCURVE('',#14035,#14140); +#14140 = DEFINITIONAL_REPRESENTATION('',(#14141),#14145); +#14141 = LINE('',#14142,#14143); +#14142 = CARTESIAN_POINT('',(-5.625,7.5)); +#14143 = VECTOR('',#14144,1.); +#14144 = DIRECTION('',(-1.,1.859429471313E-15)); +#14145 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14146 = PCURVE('',#3447,#14147); +#14147 = DEFINITIONAL_REPRESENTATION('',(#14148),#14152); +#14148 = LINE('',#14149,#14150); +#14149 = CARTESIAN_POINT('',(22.75,20.375000000025)); +#14150 = VECTOR('',#14151,1.); +#14151 = DIRECTION('',(4.851080188399E-15,1.)); +#14152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14153 = ADVANCED_FACE('',(#14154),#14121,.F.); +#14154 = FACE_BOUND('',#14155,.F.); +#14155 = EDGE_LOOP('',(#14156,#14157,#14185,#14213)); +#14156 = ORIENTED_EDGE('',*,*,#14105,.F.); +#14157 = ORIENTED_EDGE('',*,*,#14158,.F.); +#14158 = EDGE_CURVE('',#14159,#14106,#14161,.T.); +#14159 = VERTEX_POINT('',#14160); +#14160 = CARTESIAN_POINT('',(-32.99999999994,-49.84999999999,16.85)); +#14161 = SURFACE_CURVE('',#14162,(#14167,#14174),.PCURVE_S1.); +#14162 = CIRCLE('',#14163,1.1); +#14163 = AXIS2_PLACEMENT_3D('',#14164,#14165,#14166); +#14164 = CARTESIAN_POINT('',(-32.99999999994,-50.94999999999,16.85)); +#14165 = DIRECTION('',(-1.,-6.704039033313E-15,6.804680934328E-29)); +#14166 = DIRECTION('',(-4.740471461795E-15,0.707106781187, + -0.707106781187)); +#14167 = PCURVE('',#14121,#14168); +#14168 = DEFINITIONAL_REPRESENTATION('',(#14169),#14173); +#14169 = LINE('',#14170,#14171); +#14170 = CARTESIAN_POINT('',(-6.28318530718,7.5)); +#14171 = VECTOR('',#14172,1.); +#14172 = DIRECTION('',(1.,-1.130863886743E-15)); +#14173 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14174 = PCURVE('',#3447,#14175); +#14175 = DEFINITIONAL_REPRESENTATION('',(#14176),#14184); +#14176 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14177,#14178,#14179,#14180 + ,#14181,#14182,#14183),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14177 = CARTESIAN_POINT('',(22.427817459305,14.42781745933)); +#14178 = CARTESIAN_POINT('',(23.775036817836,13.080598100799)); +#14179 = CARTESIAN_POINT('',(21.934700949613,12.587481591107)); +#14180 = CARTESIAN_POINT('',(20.09436508139,12.094365081415)); +#14181 = CARTESIAN_POINT('',(20.587481591082,13.934700949638)); +#14182 = CARTESIAN_POINT('',(21.080598100774,15.775036817861)); +#14183 = CARTESIAN_POINT('',(22.427817459305,14.42781745933)); +#14184 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14185 = ORIENTED_EDGE('',*,*,#14186,.F.); +#14186 = EDGE_CURVE('',#14187,#14159,#14189,.T.); +#14187 = VERTEX_POINT('',#14188); +#14188 = CARTESIAN_POINT('',(-27.49999999994,-49.84999999999,16.85)); +#14189 = SURFACE_CURVE('',#14190,(#14194,#14201),.PCURVE_S1.); +#14190 = LINE('',#14191,#14192); +#14191 = CARTESIAN_POINT('',(-25.49999999994,-49.84999999999,16.85)); +#14192 = VECTOR('',#14193,1.); +#14193 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14194 = PCURVE('',#14121,#14195); +#14195 = DEFINITIONAL_REPRESENTATION('',(#14196),#14200); +#14196 = LINE('',#14197,#14198); +#14197 = CARTESIAN_POINT('',(-0.785398163397,-5.329070518201E-15)); +#14198 = VECTOR('',#14199,1.); +#14199 = DIRECTION('',(-8.074349270001E-16,1.)); +#14200 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14201 = PCURVE('',#14202,#14207); +#14202 = PLANE('',#14203); +#14203 = AXIS2_PLACEMENT_3D('',#14204,#14205,#14206); +#14204 = CARTESIAN_POINT('',(-25.49999999994,-49.84999999999,25.25)); +#14205 = DIRECTION('',(-4.864065825301E-15,1.,1.747384624717E-15)); +#14206 = DIRECTION('',(-7.52233495721E-29,1.747384624717E-15,-1.)); +#14207 = DEFINITIONAL_REPRESENTATION('',(#14208),#14212); +#14208 = LINE('',#14209,#14210); +#14209 = CARTESIAN_POINT('',(8.4,-1.185386902857E-27)); +#14210 = VECTOR('',#14211,1.); +#14211 = DIRECTION('',(-3.63802804026E-32,1.)); +#14212 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14213 = ORIENTED_EDGE('',*,*,#14214,.F.); +#14214 = EDGE_CURVE('',#14083,#14187,#14215,.T.); +#14215 = SURFACE_CURVE('',#14216,(#14221,#14228),.PCURVE_S1.); +#14216 = CIRCLE('',#14217,1.1); +#14217 = AXIS2_PLACEMENT_3D('',#14218,#14219,#14220); +#14218 = CARTESIAN_POINT('',(-27.49999999994,-50.94999999999,16.85)); +#14219 = DIRECTION('',(1.,4.440892098501E-15,-6.660553705895E-29)); +#14220 = DIRECTION('',(-3.140184917368E-15,0.707106781187, + -0.707106781187)); +#14221 = PCURVE('',#14121,#14222); +#14222 = DEFINITIONAL_REPRESENTATION('',(#14223),#14227); +#14223 = LINE('',#14224,#14225); +#14224 = CARTESIAN_POINT('',(6.28318530718,2.)); +#14225 = VECTOR('',#14226,1.); +#14226 = DIRECTION('',(-1.,0.)); +#14227 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14228 = PCURVE('',#14062,#14229); +#14229 = DEFINITIONAL_REPRESENTATION('',(#14230),#14238); +#14230 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14231,#14232,#14233,#14234 + ,#14235,#14236,#14237),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14231 = CARTESIAN_POINT('',(-4.427817459305,1.427817459305)); +#14232 = CARTESIAN_POINT('',(-3.080598100774,2.775036817836)); +#14233 = CARTESIAN_POINT('',(-2.587481591082,0.934700949613)); +#14234 = CARTESIAN_POINT('',(-2.09436508139,-0.90563491861)); +#14235 = CARTESIAN_POINT('',(-3.934700949613,-0.412518408918)); +#14236 = CARTESIAN_POINT('',(-5.775036817836,8.059810077445E-02)); +#14237 = CARTESIAN_POINT('',(-4.427817459305,1.427817459305)); +#14238 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14239 = ADVANCED_FACE('',(#14240),#14202,.F.); +#14240 = FACE_BOUND('',#14241,.T.); +#14241 = EDGE_LOOP('',(#14242,#14243,#14266,#14294)); +#14242 = ORIENTED_EDGE('',*,*,#14186,.F.); +#14243 = ORIENTED_EDGE('',*,*,#14244,.T.); +#14244 = EDGE_CURVE('',#14187,#14245,#14247,.T.); +#14245 = VERTEX_POINT('',#14246); +#14246 = CARTESIAN_POINT('',(-27.49999999994,-49.84999999999,24.15)); +#14247 = SURFACE_CURVE('',#14248,(#14252,#14259),.PCURVE_S1.); +#14248 = LINE('',#14249,#14250); +#14249 = CARTESIAN_POINT('',(-27.49999999994,-49.84999999999,22.875)); +#14250 = VECTOR('',#14251,1.); +#14251 = DIRECTION('',(7.446845875371E-29,-1.747384624717E-15,1.)); +#14252 = PCURVE('',#14202,#14253); +#14253 = DEFINITIONAL_REPRESENTATION('',(#14254),#14258); +#14254 = LINE('',#14255,#14256); +#14255 = CARTESIAN_POINT('',(2.375,2.)); +#14256 = VECTOR('',#14257,1.); +#14257 = DIRECTION('',(-1.,7.548908183933E-31)); +#14258 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14259 = PCURVE('',#14062,#14260); +#14260 = DEFINITIONAL_REPRESENTATION('',(#14261),#14265); +#14261 = LINE('',#14262,#14263); +#14262 = CARTESIAN_POINT('',(2.375,1.75)); +#14263 = VECTOR('',#14264,1.); +#14264 = DIRECTION('',(1.,-1.869849304632E-15)); +#14265 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14266 = ORIENTED_EDGE('',*,*,#14267,.F.); +#14267 = EDGE_CURVE('',#14268,#14245,#14270,.T.); +#14268 = VERTEX_POINT('',#14269); +#14269 = CARTESIAN_POINT('',(-32.99999999994,-49.84999999999,24.15)); +#14270 = SURFACE_CURVE('',#14271,(#14275,#14282),.PCURVE_S1.); +#14271 = LINE('',#14272,#14273); +#14272 = CARTESIAN_POINT('',(-25.49999999994,-49.84999999999,24.15)); +#14273 = VECTOR('',#14274,1.); +#14274 = DIRECTION('',(1.,4.864065825301E-15,-6.676033601576E-29)); +#14275 = PCURVE('',#14202,#14276); +#14276 = DEFINITIONAL_REPRESENTATION('',(#14277),#14281); +#14277 = LINE('',#14278,#14279); +#14278 = CARTESIAN_POINT('',(1.1,-1.461774770354E-28)); +#14279 = VECTOR('',#14280,1.); +#14280 = DIRECTION('',(3.63802804026E-32,-1.)); +#14281 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14282 = PCURVE('',#14283,#14288); +#14283 = CYLINDRICAL_SURFACE('',#14284,1.1); +#14284 = AXIS2_PLACEMENT_3D('',#14285,#14286,#14287); +#14285 = CARTESIAN_POINT('',(-25.49999999994,-50.94999999999,24.15)); +#14286 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14287 = DIRECTION('',(-3.439413929208E-15,0.707106781187,0.707106781187 + )); +#14288 = DEFINITIONAL_REPRESENTATION('',(#14289),#14293); +#14289 = LINE('',#14290,#14291); +#14290 = CARTESIAN_POINT('',(0.785398163397,-5.329070518201E-15)); +#14291 = VECTOR('',#14292,1.); +#14292 = DIRECTION('',(8.478066733501E-16,-1.)); +#14293 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14294 = ORIENTED_EDGE('',*,*,#14295,.F.); +#14295 = EDGE_CURVE('',#14159,#14268,#14296,.T.); +#14296 = SURFACE_CURVE('',#14297,(#14301,#14308),.PCURVE_S1.); +#14297 = LINE('',#14298,#14299); +#14298 = CARTESIAN_POINT('',(-32.99999999994,-49.84999999999,14.875)); +#14299 = VECTOR('',#14300,1.); +#14300 = DIRECTION('',(7.870020247605E-29,-1.747384624717E-15,1.)); +#14301 = PCURVE('',#14202,#14302); +#14302 = DEFINITIONAL_REPRESENTATION('',(#14303),#14307); +#14303 = LINE('',#14304,#14305); +#14304 = CARTESIAN_POINT('',(10.375,7.5)); +#14305 = VECTOR('',#14306,1.); +#14306 = DIRECTION('',(-1.,-3.476852903946E-30)); +#14307 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14308 = PCURVE('',#3447,#14309); +#14309 = DEFINITIONAL_REPRESENTATION('',(#14310),#14314); +#14310 = LINE('',#14311,#14312); +#14311 = CARTESIAN_POINT('',(23.625,14.750000000025)); +#14312 = VECTOR('',#14313,1.); +#14313 = DIRECTION('',(-1.,-2.094074371662E-15)); +#14314 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14315 = ADVANCED_FACE('',(#14316),#14330,.F.); +#14316 = FACE_BOUND('',#14317,.F.); +#14317 = EDGE_LOOP('',(#14318,#14353,#14381,#14404)); +#14318 = ORIENTED_EDGE('',*,*,#14319,.F.); +#14319 = EDGE_CURVE('',#14320,#14322,#14324,.T.); +#14320 = VERTEX_POINT('',#14321); +#14321 = CARTESIAN_POINT('',(-32.99999999994,-52.24999999999,25.25)); +#14322 = VERTEX_POINT('',#14323); +#14323 = CARTESIAN_POINT('',(-27.49999999994,-52.24999999999,25.25)); +#14324 = SURFACE_CURVE('',#14325,(#14329,#14341),.PCURVE_S1.); +#14325 = LINE('',#14326,#14327); +#14326 = CARTESIAN_POINT('',(-25.49999999994,-52.24999999999,25.25)); +#14327 = VECTOR('',#14328,1.); +#14328 = DIRECTION('',(1.,4.864065825301E-15,-6.676033601576E-29)); +#14329 = PCURVE('',#14330,#14335); +#14330 = CYLINDRICAL_SURFACE('',#14331,1.1); +#14331 = AXIS2_PLACEMENT_3D('',#14332,#14333,#14334); +#14332 = CARTESIAN_POINT('',(-25.49999999994,-52.24999999999,24.15)); +#14333 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14334 = DIRECTION('',(3.439413929208E-15,-0.707106781187,0.707106781187 + )); +#14335 = DEFINITIONAL_REPRESENTATION('',(#14336),#14340); +#14336 = LINE('',#14337,#14338); +#14337 = CARTESIAN_POINT('',(7.068583470577,-1.7763568394E-15)); +#14338 = VECTOR('',#14339,1.); +#14339 = DIRECTION('',(2.482862400525E-15,-1.)); +#14340 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14341 = PCURVE('',#14342,#14347); +#14342 = PLANE('',#14343); +#14343 = AXIS2_PLACEMENT_3D('',#14344,#14345,#14346); +#14344 = CARTESIAN_POINT('',(-25.49999999994,-53.34999999999,25.25)); +#14345 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#14346 = DIRECTION('',(-4.844609562001E-15,1.,-1.224646799147E-16)); +#14347 = DEFINITIONAL_REPRESENTATION('',(#14348),#14352); +#14348 = LINE('',#14349,#14350); +#14349 = CARTESIAN_POINT('',(1.1,-5.329070518201E-15)); +#14350 = VECTOR('',#14351,1.); +#14351 = DIRECTION('',(1.945626330019E-17,-1.)); +#14352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14353 = ORIENTED_EDGE('',*,*,#14354,.F.); +#14354 = EDGE_CURVE('',#14355,#14320,#14357,.T.); +#14355 = VERTEX_POINT('',#14356); +#14356 = CARTESIAN_POINT('',(-32.99999999994,-53.34999999999,24.15)); +#14357 = SURFACE_CURVE('',#14358,(#14363,#14370),.PCURVE_S1.); +#14358 = CIRCLE('',#14359,1.1); +#14359 = AXIS2_PLACEMENT_3D('',#14360,#14361,#14362); +#14360 = CARTESIAN_POINT('',(-32.99999999994,-52.24999999999,24.15)); +#14361 = DIRECTION('',(-1.,-6.704039033313E-15,6.814469407735E-29)); +#14362 = DIRECTION('',(4.740471461795E-15,-0.707106781187,0.707106781187 + )); +#14363 = PCURVE('',#14330,#14364); +#14364 = DEFINITIONAL_REPRESENTATION('',(#14365),#14369); +#14365 = LINE('',#14366,#14367); +#14366 = CARTESIAN_POINT('',(-5.329070518201E-15,7.5)); +#14367 = VECTOR('',#14368,1.); +#14368 = DIRECTION('',(1.,1.130863886743E-15)); +#14369 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14370 = PCURVE('',#3447,#14371); +#14371 = DEFINITIONAL_REPRESENTATION('',(#14372),#14380); +#14372 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14373,#14374,#14375,#14376 + ,#14377,#14378,#14379),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14373 = CARTESIAN_POINT('',(13.572182540695,11.57218254072)); +#14374 = CARTESIAN_POINT('',(12.224963182164,12.919401899251)); +#14375 = CARTESIAN_POINT('',(14.065299050387,13.412518408943)); +#14376 = CARTESIAN_POINT('',(15.90563491861,13.905634918635)); +#14377 = CARTESIAN_POINT('',(15.412518408918,12.065299050412)); +#14378 = CARTESIAN_POINT('',(14.919401899226,10.224963182189)); +#14379 = CARTESIAN_POINT('',(13.572182540695,11.57218254072)); +#14380 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14381 = ORIENTED_EDGE('',*,*,#14382,.F.); +#14382 = EDGE_CURVE('',#14383,#14355,#14385,.T.); +#14383 = VERTEX_POINT('',#14384); +#14384 = CARTESIAN_POINT('',(-27.49999999994,-53.34999999999,24.15)); +#14385 = SURFACE_CURVE('',#14386,(#14390,#14397),.PCURVE_S1.); +#14386 = LINE('',#14387,#14388); +#14387 = CARTESIAN_POINT('',(-25.49999999994,-53.34999999999,24.15)); +#14388 = VECTOR('',#14389,1.); +#14389 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14390 = PCURVE('',#14330,#14391); +#14391 = DEFINITIONAL_REPRESENTATION('',(#14392),#14396); +#14392 = LINE('',#14393,#14394); +#14393 = CARTESIAN_POINT('',(5.497787143782,3.552713678801E-15)); +#14394 = VECTOR('',#14395,1.); +#14395 = DIRECTION('',(0.,1.)); +#14396 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14397 = PCURVE('',#13979,#14398); +#14398 = DEFINITIONAL_REPRESENTATION('',(#14399),#14403); +#14399 = LINE('',#14400,#14401); +#14400 = CARTESIAN_POINT('',(8.4,1.047753026031E-27)); +#14401 = VECTOR('',#14402,1.); +#14402 = DIRECTION('',(-3.63802804026E-32,1.)); +#14403 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14404 = ORIENTED_EDGE('',*,*,#14405,.F.); +#14405 = EDGE_CURVE('',#14322,#14383,#14406,.T.); +#14406 = SURFACE_CURVE('',#14407,(#14412,#14419),.PCURVE_S1.); +#14407 = CIRCLE('',#14408,1.1); +#14408 = AXIS2_PLACEMENT_3D('',#14409,#14410,#14411); +#14409 = CARTESIAN_POINT('',(-27.49999999994,-52.24999999999,24.15)); +#14410 = DIRECTION('',(1.,4.440892098501E-15,-6.635055883021E-29)); +#14411 = DIRECTION('',(3.140184917368E-15,-0.707106781187,0.707106781187 + )); +#14412 = PCURVE('',#14330,#14413); +#14413 = DEFINITIONAL_REPRESENTATION('',(#14414),#14418); +#14414 = LINE('',#14415,#14416); +#14415 = CARTESIAN_POINT('',(12.566370614359,2.)); +#14416 = VECTOR('',#14417,1.); +#14417 = DIRECTION('',(-1.,0.)); +#14418 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14419 = PCURVE('',#14062,#14420); +#14420 = DEFINITIONAL_REPRESENTATION('',(#14421),#14429); +#14421 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14422,#14423,#14424,#14425 + ,#14426,#14427,#14428),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14422 = CARTESIAN_POINT('',(4.427817459305,-1.427817459305)); +#14423 = CARTESIAN_POINT('',(3.080598100774,-2.775036817836)); +#14424 = CARTESIAN_POINT('',(2.587481591082,-0.934700949613)); +#14425 = CARTESIAN_POINT('',(2.09436508139,0.90563491861)); +#14426 = CARTESIAN_POINT('',(3.934700949613,0.412518408918)); +#14427 = CARTESIAN_POINT('',(5.775036817836,-8.059810077444E-02)); +#14428 = CARTESIAN_POINT('',(4.427817459305,-1.427817459305)); +#14429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14430 = ADVANCED_FACE('',(#14431),#13979,.F.); +#14431 = FACE_BOUND('',#14432,.T.); +#14432 = EDGE_LOOP('',(#14433,#14434,#14455,#14456)); +#14433 = ORIENTED_EDGE('',*,*,#13956,.F.); +#14434 = ORIENTED_EDGE('',*,*,#14435,.F.); +#14435 = EDGE_CURVE('',#14355,#13957,#14436,.T.); +#14436 = SURFACE_CURVE('',#14437,(#14441,#14448),.PCURVE_S1.); +#14437 = LINE('',#14438,#14439); +#14438 = CARTESIAN_POINT('',(-32.99999999994,-53.34999999999,10.125)); +#14439 = VECTOR('',#14440,1.); +#14440 = DIRECTION('',(-5.362911702672E-29,-1.992313984547E-15,-1.)); +#14441 = PCURVE('',#13979,#14442); +#14442 = DEFINITIONAL_REPRESENTATION('',(#14443),#14447); +#14443 = LINE('',#14444,#14445); +#14444 = CARTESIAN_POINT('',(-5.625,7.5)); +#14445 = VECTOR('',#14446,1.); +#14446 = DIRECTION('',(-1.,-3.476852903946E-30)); +#14447 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14448 = PCURVE('',#3447,#14449); +#14449 = DEFINITIONAL_REPRESENTATION('',(#14450),#14454); +#14450 = LINE('',#14451,#14452); +#14451 = CARTESIAN_POINT('',(28.375,11.250000000025)); +#14452 = VECTOR('',#14453,1.); +#14453 = DIRECTION('',(1.,-1.645624237601E-15)); +#14454 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14455 = ORIENTED_EDGE('',*,*,#14382,.F.); +#14456 = ORIENTED_EDGE('',*,*,#14457,.T.); +#14457 = EDGE_CURVE('',#14383,#13959,#14458,.T.); +#14458 = SURFACE_CURVE('',#14459,(#14463,#14470),.PCURVE_S1.); +#14459 = LINE('',#14460,#14461); +#14460 = CARTESIAN_POINT('',(-27.49999999994,-53.34999999999,18.125)); +#14461 = VECTOR('',#14462,1.); +#14462 = DIRECTION('',(-5.786086074906E-29,-1.992313984547E-15,-1.)); +#14463 = PCURVE('',#13979,#14464); +#14464 = DEFINITIONAL_REPRESENTATION('',(#14465),#14469); +#14465 = LINE('',#14466,#14467); +#14466 = CARTESIAN_POINT('',(2.375,2.)); +#14467 = VECTOR('',#14468,1.); +#14468 = DIRECTION('',(-1.,7.548908183933E-31)); +#14469 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14470 = PCURVE('',#14062,#14471); +#14471 = DEFINITIONAL_REPRESENTATION('',(#14472),#14476); +#14472 = LINE('',#14473,#14474); +#14473 = CARTESIAN_POINT('',(-2.375,-1.75)); +#14474 = VECTOR('',#14475,1.); +#14475 = DIRECTION('',(-1.,-1.869849304632E-15)); +#14476 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14477 = ADVANCED_FACE('',(#14478),#14283,.F.); +#14478 = FACE_BOUND('',#14479,.F.); +#14479 = EDGE_LOOP('',(#14480,#14481,#14509,#14532)); +#14480 = ORIENTED_EDGE('',*,*,#14267,.F.); +#14481 = ORIENTED_EDGE('',*,*,#14482,.F.); +#14482 = EDGE_CURVE('',#14483,#14268,#14485,.T.); +#14483 = VERTEX_POINT('',#14484); +#14484 = CARTESIAN_POINT('',(-32.99999999994,-50.94999999999,25.25)); +#14485 = SURFACE_CURVE('',#14486,(#14491,#14498),.PCURVE_S1.); +#14486 = CIRCLE('',#14487,1.1); +#14487 = AXIS2_PLACEMENT_3D('',#14488,#14489,#14490); +#14488 = CARTESIAN_POINT('',(-32.99999999994,-50.94999999999,24.15)); +#14489 = DIRECTION('',(-1.,-6.704039033313E-15,6.768700734392E-29)); +#14490 = DIRECTION('',(-4.740471461795E-15,0.707106781187,0.707106781187 + )); +#14491 = PCURVE('',#14283,#14492); +#14492 = DEFINITIONAL_REPRESENTATION('',(#14493),#14497); +#14493 = LINE('',#14494,#14495); +#14494 = CARTESIAN_POINT('',(-6.28318530718,7.5)); +#14495 = VECTOR('',#14496,1.); +#14496 = DIRECTION('',(1.,1.130863886743E-15)); +#14497 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14498 = PCURVE('',#3447,#14499); +#14499 = DEFINITIONAL_REPRESENTATION('',(#14500),#14508); +#14500 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14501,#14502,#14503,#14504 + ,#14505,#14506,#14507),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14501 = CARTESIAN_POINT('',(13.572182540695,14.42781745933)); +#14502 = CARTESIAN_POINT('',(14.919401899226,15.775036817861)); +#14503 = CARTESIAN_POINT('',(15.412518408918,13.934700949638)); +#14504 = CARTESIAN_POINT('',(15.90563491861,12.094365081415)); +#14505 = CARTESIAN_POINT('',(14.065299050387,12.587481591107)); +#14506 = CARTESIAN_POINT('',(12.224963182164,13.080598100799)); +#14507 = CARTESIAN_POINT('',(13.572182540695,14.42781745933)); +#14508 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14509 = ORIENTED_EDGE('',*,*,#14510,.F.); +#14510 = EDGE_CURVE('',#14511,#14483,#14513,.T.); +#14511 = VERTEX_POINT('',#14512); +#14512 = CARTESIAN_POINT('',(-27.49999999994,-50.94999999999,25.25)); +#14513 = SURFACE_CURVE('',#14514,(#14518,#14525),.PCURVE_S1.); +#14514 = LINE('',#14515,#14516); +#14515 = CARTESIAN_POINT('',(-25.49999999994,-50.94999999999,25.25)); +#14516 = VECTOR('',#14517,1.); +#14517 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14518 = PCURVE('',#14283,#14519); +#14519 = DEFINITIONAL_REPRESENTATION('',(#14520),#14524); +#14520 = LINE('',#14521,#14522); +#14521 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#14522 = VECTOR('',#14523,1.); +#14523 = DIRECTION('',(-8.074349270001E-16,1.)); +#14524 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14525 = PCURVE('',#14342,#14526); +#14526 = DEFINITIONAL_REPRESENTATION('',(#14527),#14531); +#14527 = LINE('',#14528,#14529); +#14528 = CARTESIAN_POINT('',(2.4,-1.16270629488E-14)); +#14529 = VECTOR('',#14530,1.); +#14530 = DIRECTION('',(-1.945626330019E-17,1.)); +#14531 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14532 = ORIENTED_EDGE('',*,*,#14533,.F.); +#14533 = EDGE_CURVE('',#14245,#14511,#14534,.T.); +#14534 = SURFACE_CURVE('',#14535,(#14540,#14547),.PCURVE_S1.); +#14535 = CIRCLE('',#14536,1.1); +#14536 = AXIS2_PLACEMENT_3D('',#14537,#14538,#14539); +#14537 = CARTESIAN_POINT('',(-27.49999999994,-50.94999999999,24.15)); +#14538 = DIRECTION('',(1.,4.440892098501E-15,-6.64324679961E-29)); +#14539 = DIRECTION('',(-3.140184917367E-15,0.707106781187,0.707106781187 + )); +#14540 = PCURVE('',#14283,#14541); +#14541 = DEFINITIONAL_REPRESENTATION('',(#14542),#14546); +#14542 = LINE('',#14543,#14544); +#14543 = CARTESIAN_POINT('',(6.28318530718,2.)); +#14544 = VECTOR('',#14545,1.); +#14545 = DIRECTION('',(-1.,0.)); +#14546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14547 = PCURVE('',#14062,#14548); +#14548 = DEFINITIONAL_REPRESENTATION('',(#14549),#14557); +#14549 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#14550,#14551,#14552,#14553 + ,#14554,#14555,#14556),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#14550 = CARTESIAN_POINT('',(4.427817459305,1.427817459305)); +#14551 = CARTESIAN_POINT('',(5.775036817836,8.059810077444E-02)); +#14552 = CARTESIAN_POINT('',(3.934700949613,-0.412518408918)); +#14553 = CARTESIAN_POINT('',(2.09436508139,-0.90563491861)); +#14554 = CARTESIAN_POINT('',(2.587481591082,0.934700949613)); +#14555 = CARTESIAN_POINT('',(3.080598100774,2.775036817836)); +#14556 = CARTESIAN_POINT('',(4.427817459305,1.427817459305)); +#14557 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14558 = ADVANCED_FACE('',(#14559),#14342,.F.); +#14559 = FACE_BOUND('',#14560,.T.); +#14560 = EDGE_LOOP('',(#14561,#14562,#14583,#14584)); +#14561 = ORIENTED_EDGE('',*,*,#14319,.F.); +#14562 = ORIENTED_EDGE('',*,*,#14563,.F.); +#14563 = EDGE_CURVE('',#14483,#14320,#14564,.T.); +#14564 = SURFACE_CURVE('',#14565,(#14569,#14576),.PCURVE_S1.); +#14565 = LINE('',#14566,#14567); +#14566 = CARTESIAN_POINT('',(-32.99999999994,-45.97499999999,25.25)); +#14567 = VECTOR('',#14568,1.); +#14568 = DIRECTION('',(6.704039033313E-15,-1.,1.224646799147E-16)); +#14569 = PCURVE('',#14342,#14570); +#14570 = DEFINITIONAL_REPRESENTATION('',(#14571),#14575); +#14571 = LINE('',#14572,#14573); +#14572 = CARTESIAN_POINT('',(7.375,7.5)); +#14573 = VECTOR('',#14574,1.); +#14574 = DIRECTION('',(-1.,-1.859429471313E-15)); +#14575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14576 = PCURVE('',#3447,#14577); +#14577 = DEFINITIONAL_REPRESENTATION('',(#14578),#14582); +#14578 = LINE('',#14579,#14580); +#14579 = CARTESIAN_POINT('',(13.25,18.625000000025)); +#14580 = VECTOR('',#14581,1.); +#14581 = DIRECTION('',(2.242250670306E-16,-1.)); +#14582 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14583 = ORIENTED_EDGE('',*,*,#14510,.F.); +#14584 = ORIENTED_EDGE('',*,*,#14585,.T.); +#14585 = EDGE_CURVE('',#14511,#14322,#14586,.T.); +#14586 = SURFACE_CURVE('',#14587,(#14591,#14598),.PCURVE_S1.); +#14587 = LINE('',#14588,#14589); +#14588 = CARTESIAN_POINT('',(-27.49999999994,-52.47499999999,25.25)); +#14589 = VECTOR('',#14590,1.); +#14590 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#14591 = PCURVE('',#14342,#14592); +#14592 = DEFINITIONAL_REPRESENTATION('',(#14593),#14597); +#14593 = LINE('',#14594,#14595); +#14594 = CARTESIAN_POINT('',(0.875,2.)); +#14595 = VECTOR('',#14596,1.); +#14596 = DIRECTION('',(-1.,4.037174635001E-16)); +#14597 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14598 = PCURVE('',#14062,#14599); +#14599 = DEFINITIONAL_REPRESENTATION('',(#14600),#14604); +#14600 = LINE('',#14601,#14602); +#14601 = CARTESIAN_POINT('',(4.75,-0.875)); +#14602 = VECTOR('',#14603,1.); +#14603 = DIRECTION('',(0.,-1.)); +#14604 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14605 = ADVANCED_FACE('',(#14606),#14620,.F.); +#14606 = FACE_BOUND('',#14607,.T.); +#14607 = EDGE_LOOP('',(#14608,#14638,#14666,#14689)); +#14608 = ORIENTED_EDGE('',*,*,#14609,.F.); +#14609 = EDGE_CURVE('',#14610,#14612,#14614,.T.); +#14610 = VERTEX_POINT('',#14611); +#14611 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,27.25)); +#14612 = VERTEX_POINT('',#14613); +#14613 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,27.25)); +#14614 = SURFACE_CURVE('',#14615,(#14619,#14631),.PCURVE_S1.); +#14615 = LINE('',#14616,#14617); +#14616 = CARTESIAN_POINT('',(-25.49999999994,-46.59999999999,27.25)); +#14617 = VECTOR('',#14618,1.); +#14618 = DIRECTION('',(-6.459479416001E-15,1.,-1.224646799147E-16)); +#14619 = PCURVE('',#14620,#14625); +#14620 = PLANE('',#14621); +#14621 = AXIS2_PLACEMENT_3D('',#14622,#14623,#14624); +#14622 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,27.25)); +#14623 = DIRECTION('',(6.616465975138E-29,1.224646799147E-16,1.)); +#14624 = DIRECTION('',(-4.844609562001E-15,1.,-1.224646799147E-16)); +#14625 = DEFINITIONAL_REPRESENTATION('',(#14626),#14630); +#14626 = LINE('',#14627,#14628); +#14627 = CARTESIAN_POINT('',(8.,-1.382328595024E-13)); +#14628 = VECTOR('',#14629,1.); +#14629 = DIRECTION('',(1.,1.614869854E-15)); +#14630 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14631 = PCURVE('',#3814,#14632); +#14632 = DEFINITIONAL_REPRESENTATION('',(#14633),#14637); +#14633 = LINE('',#14634,#14635); +#14634 = CARTESIAN_POINT('',(-22.75,-8.)); +#14635 = VECTOR('',#14636,1.); +#14636 = DIRECTION('',(0.,1.)); +#14637 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14638 = ORIENTED_EDGE('',*,*,#14639,.T.); +#14639 = EDGE_CURVE('',#14610,#14640,#14642,.T.); +#14640 = VERTEX_POINT('',#14641); +#14641 = CARTESIAN_POINT('',(-27.49999999994,-54.59999999999,27.25)); +#14642 = SURFACE_CURVE('',#14643,(#14647,#14654),.PCURVE_S1.); +#14643 = LINE('',#14644,#14645); +#14644 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,27.25)); +#14645 = VECTOR('',#14646,1.); +#14646 = DIRECTION('',(-1.,-4.440892098501E-15,6.670851218076E-29)); +#14647 = PCURVE('',#14620,#14648); +#14648 = DEFINITIONAL_REPRESENTATION('',(#14649),#14653); +#14649 = LINE('',#14650,#14651); +#14650 = CARTESIAN_POINT('',(0.,0.)); +#14651 = VECTOR('',#14652,1.); +#14652 = DIRECTION('',(4.037174635001E-16,1.)); +#14653 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14654 = PCURVE('',#14655,#14660); +#14655 = PLANE('',#14656); +#14656 = AXIS2_PLACEMENT_3D('',#14657,#14658,#14659); +#14657 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,13.75)); +#14658 = DIRECTION('',(4.440892098501E-15,-1.,1.438284560952E-15)); +#14659 = DIRECTION('',(5.979002617384E-29,1.438284560952E-15,1.)); +#14660 = DEFINITIONAL_REPRESENTATION('',(#14661),#14665); +#14661 = LINE('',#14662,#14663); +#14662 = CARTESIAN_POINT('',(13.5,1.691953049683E-27)); +#14663 = VECTOR('',#14664,1.); +#14664 = DIRECTION('',(5.312194647953E-31,1.)); +#14665 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14666 = ORIENTED_EDGE('',*,*,#14667,.T.); +#14667 = EDGE_CURVE('',#14640,#14668,#14670,.T.); +#14668 = VERTEX_POINT('',#14669); +#14669 = CARTESIAN_POINT('',(-27.49999999994,-48.59999999999,27.25)); +#14670 = SURFACE_CURVE('',#14671,(#14675,#14682),.PCURVE_S1.); +#14671 = LINE('',#14672,#14673); +#14672 = CARTESIAN_POINT('',(-27.49999999994,-48.59999999999,27.25)); +#14673 = VECTOR('',#14674,1.); +#14674 = DIRECTION('',(-4.844609562001E-15,1.,-1.224646799147E-16)); +#14675 = PCURVE('',#14620,#14676); +#14676 = DEFINITIONAL_REPRESENTATION('',(#14677),#14681); +#14677 = LINE('',#14678,#14679); +#14678 = CARTESIAN_POINT('',(6.,2.)); +#14679 = VECTOR('',#14680,1.); +#14680 = DIRECTION('',(1.,-1.627832526208E-44)); +#14681 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14682 = PCURVE('',#14062,#14683); +#14683 = DEFINITIONAL_REPRESENTATION('',(#14684),#14688); +#14684 = LINE('',#14685,#14686); +#14685 = CARTESIAN_POINT('',(6.75,3.)); +#14686 = VECTOR('',#14687,1.); +#14687 = DIRECTION('',(0.,1.)); +#14688 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14689 = ORIENTED_EDGE('',*,*,#14690,.F.); +#14690 = EDGE_CURVE('',#14612,#14668,#14691,.T.); +#14691 = SURFACE_CURVE('',#14692,(#14696,#14703),.PCURVE_S1.); +#14692 = LINE('',#14693,#14694); +#14693 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,27.25)); +#14694 = VECTOR('',#14695,1.); +#14695 = DIRECTION('',(-1.,-4.440892098501E-15,6.670851218076E-29)); +#14696 = PCURVE('',#14620,#14697); +#14697 = DEFINITIONAL_REPRESENTATION('',(#14698),#14702); +#14698 = LINE('',#14699,#14700); +#14699 = CARTESIAN_POINT('',(6.,-2.9067657372E-14)); +#14700 = VECTOR('',#14701,1.); +#14701 = DIRECTION('',(4.037174635001E-16,1.)); +#14702 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14703 = PCURVE('',#14704,#14709); +#14704 = PLANE('',#14705); +#14705 = AXIS2_PLACEMENT_3D('',#14706,#14707,#14708); +#14706 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,27.25)); +#14707 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#14708 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#14709 = DEFINITIONAL_REPRESENTATION('',(#14710),#14714); +#14710 = LINE('',#14711,#14712); +#14711 = CARTESIAN_POINT('',(0.,0.)); +#14712 = VECTOR('',#14713,1.); +#14713 = DIRECTION('',(0.,1.)); +#14714 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14715 = ADVANCED_FACE('',(#14716),#14655,.F.); +#14716 = FACE_BOUND('',#14717,.T.); +#14717 = EDGE_LOOP('',(#14718,#14741,#14769,#14790)); +#14718 = ORIENTED_EDGE('',*,*,#14719,.F.); +#14719 = EDGE_CURVE('',#14720,#14610,#14722,.T.); +#14720 = VERTEX_POINT('',#14721); +#14721 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,13.75)); +#14722 = SURFACE_CURVE('',#14723,(#14727,#14734),.PCURVE_S1.); +#14723 = LINE('',#14724,#14725); +#14724 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,9.125)); +#14725 = VECTOR('',#14726,1.); +#14726 = DIRECTION('',(5.766514831466E-29,1.438284560952E-15,1.)); +#14727 = PCURVE('',#14655,#14728); +#14728 = DEFINITIONAL_REPRESENTATION('',(#14729),#14733); +#14729 = LINE('',#14730,#14731); +#14730 = CARTESIAN_POINT('',(-4.625,-9.947598300641E-14)); +#14731 = VECTOR('',#14732,1.); +#14732 = DIRECTION('',(1.,2.124877859181E-30)); +#14733 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14734 = PCURVE('',#3814,#14735); +#14735 = DEFINITIONAL_REPRESENTATION('',(#14736),#14740); +#14736 = LINE('',#14737,#14738); +#14737 = CARTESIAN_POINT('',(-4.625,-16.)); +#14738 = VECTOR('',#14739,1.); +#14739 = DIRECTION('',(-1.,1.315819881037E-15)); +#14740 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14741 = ORIENTED_EDGE('',*,*,#14742,.T.); +#14742 = EDGE_CURVE('',#14720,#14743,#14745,.T.); +#14743 = VERTEX_POINT('',#14744); +#14744 = CARTESIAN_POINT('',(-27.49999999994,-54.59999999999,13.75)); +#14745 = SURFACE_CURVE('',#14746,(#14750,#14757),.PCURVE_S1.); +#14746 = LINE('',#14747,#14748); +#14747 = CARTESIAN_POINT('',(-25.49999999994,-54.59999999999,13.75)); +#14748 = VECTOR('',#14749,1.); +#14749 = DIRECTION('',(-1.,-4.440892098501E-15,6.670851218076E-29)); +#14750 = PCURVE('',#14655,#14751); +#14751 = DEFINITIONAL_REPRESENTATION('',(#14752),#14756); +#14752 = LINE('',#14753,#14754); +#14753 = CARTESIAN_POINT('',(0.,0.)); +#14754 = VECTOR('',#14755,1.); +#14755 = DIRECTION('',(5.312194647953E-31,1.)); +#14756 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14757 = PCURVE('',#14758,#14763); +#14758 = PLANE('',#14759); +#14759 = AXIS2_PLACEMENT_3D('',#14760,#14761,#14762); +#14760 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,13.75)); +#14761 = DIRECTION('',(-7.931234150507E-29,2.838130052419E-15,-1.)); +#14762 = DIRECTION('',(4.844609562001E-15,-1.,-2.838130052419E-15)); +#14763 = DEFINITIONAL_REPRESENTATION('',(#14764),#14768); +#14764 = LINE('',#14765,#14766); +#14765 = CARTESIAN_POINT('',(6.,2.9067657372E-14)); +#14766 = VECTOR('',#14767,1.); +#14767 = DIRECTION('',(-4.037174635001E-16,1.)); +#14768 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14769 = ORIENTED_EDGE('',*,*,#14770,.T.); +#14770 = EDGE_CURVE('',#14743,#14640,#14771,.T.); +#14771 = SURFACE_CURVE('',#14772,(#14776,#14783),.PCURVE_S1.); +#14772 = LINE('',#14773,#14774); +#14773 = CARTESIAN_POINT('',(-27.49999999994,-54.59999999999,27.25)); +#14774 = VECTOR('',#14775,1.); +#14775 = DIRECTION('',(5.979002617384E-29,1.438284560952E-15,1.)); +#14776 = PCURVE('',#14655,#14777); +#14777 = DEFINITIONAL_REPRESENTATION('',(#14778),#14782); +#14778 = LINE('',#14779,#14780); +#14779 = CARTESIAN_POINT('',(13.5,2.)); +#14780 = VECTOR('',#14781,1.); +#14781 = DIRECTION('',(1.,0.)); +#14782 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14783 = PCURVE('',#14062,#14784); +#14784 = DEFINITIONAL_REPRESENTATION('',(#14785),#14789); +#14785 = LINE('',#14786,#14787); +#14786 = CARTESIAN_POINT('',(6.75,-3.)); +#14787 = VECTOR('',#14788,1.); +#14788 = DIRECTION('',(1.,1.315819881037E-15)); +#14789 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14790 = ORIENTED_EDGE('',*,*,#14639,.F.); +#14791 = ADVANCED_FACE('',(#14792),#14758,.F.); +#14792 = FACE_BOUND('',#14793,.T.); +#14793 = EDGE_LOOP('',(#14794,#14817,#14840,#14861)); +#14794 = ORIENTED_EDGE('',*,*,#14795,.F.); +#14795 = EDGE_CURVE('',#14796,#14720,#14798,.T.); +#14796 = VERTEX_POINT('',#14797); +#14797 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,13.75)); +#14798 = SURFACE_CURVE('',#14799,(#14803,#14810),.PCURVE_S1.); +#14799 = LINE('',#14800,#14801); +#14800 = CARTESIAN_POINT('',(-25.49999999994,-43.59999999999,13.75)); +#14801 = VECTOR('',#14802,1.); +#14802 = DIRECTION('',(6.459479416001E-15,-1.,-2.838130052419E-15)); +#14803 = PCURVE('',#14758,#14804); +#14804 = DEFINITIONAL_REPRESENTATION('',(#14805),#14809); +#14805 = LINE('',#14806,#14807); +#14806 = CARTESIAN_POINT('',(-5.,-1.236990308164E-13)); +#14807 = VECTOR('',#14808,1.); +#14808 = DIRECTION('',(1.,-1.614869854E-15)); +#14809 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14810 = PCURVE('',#3814,#14811); +#14811 = DEFINITIONAL_REPRESENTATION('',(#14812),#14816); +#14812 = LINE('',#14813,#14814); +#14813 = CARTESIAN_POINT('',(-9.25,-5.)); +#14814 = VECTOR('',#14815,1.); +#14815 = DIRECTION('',(2.960594732334E-15,-1.)); +#14816 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14817 = ORIENTED_EDGE('',*,*,#14818,.T.); +#14818 = EDGE_CURVE('',#14796,#14819,#14821,.T.); +#14819 = VERTEX_POINT('',#14820); +#14820 = CARTESIAN_POINT('',(-27.49999999994,-48.59999999999,13.75)); +#14821 = SURFACE_CURVE('',#14822,(#14826,#14833),.PCURVE_S1.); +#14822 = LINE('',#14823,#14824); +#14823 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,13.75)); +#14824 = VECTOR('',#14825,1.); +#14825 = DIRECTION('',(-1.,-4.440892098501E-15,6.670851218076E-29)); +#14826 = PCURVE('',#14758,#14827); +#14827 = DEFINITIONAL_REPRESENTATION('',(#14828),#14832); +#14828 = LINE('',#14829,#14830); +#14829 = CARTESIAN_POINT('',(0.,0.)); +#14830 = VECTOR('',#14831,1.); +#14831 = DIRECTION('',(-4.037174635001E-16,1.)); +#14832 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14833 = PCURVE('',#14704,#14834); +#14834 = DEFINITIONAL_REPRESENTATION('',(#14835),#14839); +#14835 = LINE('',#14836,#14837); +#14836 = CARTESIAN_POINT('',(13.5,-1.793787821084E-27)); +#14837 = VECTOR('',#14838,1.); +#14838 = DIRECTION('',(0.,1.)); +#14839 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14840 = ORIENTED_EDGE('',*,*,#14841,.T.); +#14841 = EDGE_CURVE('',#14819,#14743,#14842,.T.); +#14842 = SURFACE_CURVE('',#14843,(#14847,#14854),.PCURVE_S1.); +#14843 = LINE('',#14844,#14845); +#14844 = CARTESIAN_POINT('',(-27.49999999994,-54.59999999999,13.75)); +#14845 = VECTOR('',#14846,1.); +#14846 = DIRECTION('',(4.844609562001E-15,-1.,-2.838130052419E-15)); +#14847 = PCURVE('',#14758,#14848); +#14848 = DEFINITIONAL_REPRESENTATION('',(#14849),#14853); +#14849 = LINE('',#14850,#14851); +#14850 = CARTESIAN_POINT('',(6.,2.)); +#14851 = VECTOR('',#14852,1.); +#14852 = DIRECTION('',(1.,-3.738594054408E-43)); +#14853 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14854 = PCURVE('',#14062,#14855); +#14855 = DEFINITIONAL_REPRESENTATION('',(#14856),#14860); +#14856 = LINE('',#14857,#14858); +#14857 = CARTESIAN_POINT('',(-6.75,-3.)); +#14858 = VECTOR('',#14859,1.); +#14859 = DIRECTION('',(-2.960594732334E-15,-1.)); +#14860 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14861 = ORIENTED_EDGE('',*,*,#14742,.F.); +#14862 = ADVANCED_FACE('',(#14863),#14704,.F.); +#14863 = FACE_BOUND('',#14864,.T.); +#14864 = EDGE_LOOP('',(#14865,#14886,#14887,#14908)); +#14865 = ORIENTED_EDGE('',*,*,#14866,.F.); +#14866 = EDGE_CURVE('',#14612,#14796,#14867,.T.); +#14867 = SURFACE_CURVE('',#14868,(#14872,#14879),.PCURVE_S1.); +#14868 = LINE('',#14869,#14870); +#14869 = CARTESIAN_POINT('',(-25.49999999994,-48.59999999999,15.875)); +#14870 = VECTOR('',#14871,1.); +#14871 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#14872 = PCURVE('',#14704,#14873); +#14873 = DEFINITIONAL_REPRESENTATION('',(#14874),#14878); +#14874 = LINE('',#14875,#14876); +#14875 = CARTESIAN_POINT('',(11.375,-9.947598300642E-14)); +#14876 = VECTOR('',#14877,1.); +#14877 = DIRECTION('',(1.,0.)); +#14878 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14879 = PCURVE('',#3814,#14880); +#14880 = DEFINITIONAL_REPRESENTATION('',(#14881),#14885); +#14881 = LINE('',#14882,#14883); +#14882 = CARTESIAN_POINT('',(-11.375,-10.)); +#14883 = VECTOR('',#14884,1.); +#14884 = DIRECTION('',(1.,0.)); +#14885 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14886 = ORIENTED_EDGE('',*,*,#14690,.T.); +#14887 = ORIENTED_EDGE('',*,*,#14888,.T.); +#14888 = EDGE_CURVE('',#14668,#14819,#14889,.T.); +#14889 = SURFACE_CURVE('',#14890,(#14894,#14901),.PCURVE_S1.); +#14890 = LINE('',#14891,#14892); +#14891 = CARTESIAN_POINT('',(-27.49999999994,-48.59999999999,13.75)); +#14892 = VECTOR('',#14893,1.); +#14893 = DIRECTION('',(-6.616465975138E-29,-1.224646799147E-16,-1.)); +#14894 = PCURVE('',#14704,#14895); +#14895 = DEFINITIONAL_REPRESENTATION('',(#14896),#14900); +#14896 = LINE('',#14897,#14898); +#14897 = CARTESIAN_POINT('',(13.5,2.)); +#14898 = VECTOR('',#14899,1.); +#14899 = DIRECTION('',(1.,0.)); +#14900 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14901 = PCURVE('',#14062,#14902); +#14902 = DEFINITIONAL_REPRESENTATION('',(#14903),#14907); +#14903 = LINE('',#14904,#14905); +#14904 = CARTESIAN_POINT('',(-6.75,3.)); +#14905 = VECTOR('',#14906,1.); +#14906 = DIRECTION('',(-1.,0.)); +#14907 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14908 = ORIENTED_EDGE('',*,*,#14818,.F.); +#14909 = ADVANCED_FACE('',(#14910,#14916),#14062,.F.); +#14910 = FACE_BOUND('',#14911,.T.); +#14911 = EDGE_LOOP('',(#14912,#14913,#14914,#14915)); +#14912 = ORIENTED_EDGE('',*,*,#14888,.F.); +#14913 = ORIENTED_EDGE('',*,*,#14667,.F.); +#14914 = ORIENTED_EDGE('',*,*,#14770,.F.); +#14915 = ORIENTED_EDGE('',*,*,#14841,.F.); +#14916 = FACE_BOUND('',#14917,.T.); +#14917 = EDGE_LOOP('',(#14918,#14919,#14920,#14921,#14922,#14923,#14924, + #14925)); +#14918 = ORIENTED_EDGE('',*,*,#14214,.F.); +#14919 = ORIENTED_EDGE('',*,*,#14082,.F.); +#14920 = ORIENTED_EDGE('',*,*,#14047,.F.); +#14921 = ORIENTED_EDGE('',*,*,#14457,.F.); +#14922 = ORIENTED_EDGE('',*,*,#14405,.F.); +#14923 = ORIENTED_EDGE('',*,*,#14585,.F.); +#14924 = ORIENTED_EDGE('',*,*,#14533,.F.); +#14925 = ORIENTED_EDGE('',*,*,#14244,.F.); +#14926 = ADVANCED_FACE('',(#14927),#14941,.F.); +#14927 = FACE_BOUND('',#14928,.F.); +#14928 = EDGE_LOOP('',(#14929,#14959,#14981,#14982)); +#14929 = ORIENTED_EDGE('',*,*,#14930,.T.); +#14930 = EDGE_CURVE('',#14931,#14933,#14935,.T.); +#14931 = VERTEX_POINT('',#14932); +#14932 = CARTESIAN_POINT('',(-25.49999999994,-57.94999999999,33.4)); +#14933 = VERTEX_POINT('',#14934); +#14934 = CARTESIAN_POINT('',(-32.99999999994,-57.94999999999,33.4)); +#14935 = SEAM_CURVE('',#14936,(#14940,#14952),.PCURVE_S1.); +#14936 = LINE('',#14937,#14938); +#14937 = CARTESIAN_POINT('',(-25.49999999994,-57.94999999999,33.4)); +#14938 = VECTOR('',#14939,1.); +#14939 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14940 = PCURVE('',#14941,#14946); +#14941 = CYLINDRICAL_SURFACE('',#14942,1.05); +#14942 = AXIS2_PLACEMENT_3D('',#14943,#14944,#14945); +#14943 = CARTESIAN_POINT('',(-25.49999999994,-56.89999999999,33.4)); +#14944 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#14945 = DIRECTION('',(-4.864065825301E-15,1.,-1.224646799147E-16)); +#14946 = DEFINITIONAL_REPRESENTATION('',(#14947),#14951); +#14947 = LINE('',#14948,#14949); +#14948 = CARTESIAN_POINT('',(9.424777960769,-9.592326932761E-14)); +#14949 = VECTOR('',#14950,1.); +#14950 = DIRECTION('',(0.,1.)); +#14951 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14952 = PCURVE('',#14941,#14953); +#14953 = DEFINITIONAL_REPRESENTATION('',(#14954),#14958); +#14954 = LINE('',#14955,#14956); +#14955 = CARTESIAN_POINT('',(3.14159265359,-9.592326932761E-14)); +#14956 = VECTOR('',#14957,1.); +#14957 = DIRECTION('',(0.,1.)); +#14958 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14959 = ORIENTED_EDGE('',*,*,#14960,.T.); +#14960 = EDGE_CURVE('',#14933,#14933,#14961,.T.); +#14961 = SURFACE_CURVE('',#14962,(#14967,#14974),.PCURVE_S1.); +#14962 = CIRCLE('',#14963,1.05); +#14963 = AXIS2_PLACEMENT_3D('',#14964,#14965,#14966); +#14964 = CARTESIAN_POINT('',(-32.99999999994,-56.89999999999,33.4)); +#14965 = DIRECTION('',(1.,6.704039033313E-15,-6.698566774573E-29)); +#14966 = DIRECTION('',(-6.704039033313E-15,1.,-1.224646799147E-16)); +#14967 = PCURVE('',#14941,#14968); +#14968 = DEFINITIONAL_REPRESENTATION('',(#14969),#14973); +#14969 = LINE('',#14970,#14971); +#14970 = CARTESIAN_POINT('',(12.566370614359,7.5)); +#14971 = VECTOR('',#14972,1.); +#14972 = DIRECTION('',(-1.,0.)); +#14973 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14974 = PCURVE('',#3447,#14975); +#14975 = DEFINITIONAL_REPRESENTATION('',(#14976),#14980); +#14976 = CIRCLE('',#14977,1.05); +#14977 = AXIS2_PLACEMENT_2D('',#14978,#14979); +#14978 = CARTESIAN_POINT('',(5.1,7.700000000025)); +#14979 = DIRECTION('',(-2.242250670306E-16,1.)); +#14980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14981 = ORIENTED_EDGE('',*,*,#14930,.F.); +#14982 = ORIENTED_EDGE('',*,*,#14983,.T.); +#14983 = EDGE_CURVE('',#14931,#14931,#14984,.T.); +#14984 = SURFACE_CURVE('',#14985,(#14990,#14997),.PCURVE_S1.); +#14985 = CIRCLE('',#14986,1.05); +#14986 = AXIS2_PLACEMENT_3D('',#14987,#14988,#14989); +#14987 = CARTESIAN_POINT('',(-25.49999999994,-56.89999999999,33.4)); +#14988 = DIRECTION('',(-1.,-6.459479416001E-15,6.695571783048E-29)); +#14989 = DIRECTION('',(-6.459479416001E-15,1.,-1.224646799147E-16)); +#14990 = PCURVE('',#14941,#14991); +#14991 = DEFINITIONAL_REPRESENTATION('',(#14992),#14996); +#14992 = LINE('',#14993,#14994); +#14993 = CARTESIAN_POINT('',(0.,-1.030286966852E-13)); +#14994 = VECTOR('',#14995,1.); +#14995 = DIRECTION('',(1.,0.)); +#14996 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#14997 = PCURVE('',#3814,#14998); +#14998 = DEFINITIONAL_REPRESENTATION('',(#14999),#15007); +#14999 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15000,#15001,#15002,#15003 + ,#15004,#15005,#15006),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15000 = CARTESIAN_POINT('',(-28.9,-17.25)); +#15001 = CARTESIAN_POINT('',(-27.08134665205,-17.25)); +#15002 = CARTESIAN_POINT('',(-27.99067332602,-18.825)); +#15003 = CARTESIAN_POINT('',(-28.9,-20.4)); +#15004 = CARTESIAN_POINT('',(-29.80932667397,-18.825)); +#15005 = CARTESIAN_POINT('',(-30.71865334794,-17.25)); +#15006 = CARTESIAN_POINT('',(-28.9,-17.25)); +#15007 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15008 = ADVANCED_FACE('',(#15009),#15023,.F.); +#15009 = FACE_BOUND('',#15010,.F.); +#15010 = EDGE_LOOP('',(#15011,#15041,#15063,#15064)); +#15011 = ORIENTED_EDGE('',*,*,#15012,.T.); +#15012 = EDGE_CURVE('',#15013,#15015,#15017,.T.); +#15013 = VERTEX_POINT('',#15014); +#15014 = CARTESIAN_POINT('',(-25.49999999994,-47.34999999999,33.4)); +#15015 = VERTEX_POINT('',#15016); +#15016 = CARTESIAN_POINT('',(-32.99999999994,-47.34999999999,33.4)); +#15017 = SEAM_CURVE('',#15018,(#15022,#15034),.PCURVE_S1.); +#15018 = LINE('',#15019,#15020); +#15019 = CARTESIAN_POINT('',(-25.49999999994,-47.34999999999,33.4)); +#15020 = VECTOR('',#15021,1.); +#15021 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15022 = PCURVE('',#15023,#15028); +#15023 = CYLINDRICAL_SURFACE('',#15024,1.05); +#15024 = AXIS2_PLACEMENT_3D('',#15025,#15026,#15027); +#15025 = CARTESIAN_POINT('',(-25.49999999994,-46.29999999999,33.4)); +#15026 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15027 = DIRECTION('',(-4.864065825301E-15,1.,-1.224646799147E-16)); +#15028 = DEFINITIONAL_REPRESENTATION('',(#15029),#15033); +#15029 = LINE('',#15030,#15031); +#15030 = CARTESIAN_POINT('',(9.424777960769,7.105427357601E-15)); +#15031 = VECTOR('',#15032,1.); +#15032 = DIRECTION('',(0.,1.)); +#15033 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15034 = PCURVE('',#15023,#15035); +#15035 = DEFINITIONAL_REPRESENTATION('',(#15036),#15040); +#15036 = LINE('',#15037,#15038); +#15037 = CARTESIAN_POINT('',(3.14159265359,7.105427357601E-15)); +#15038 = VECTOR('',#15039,1.); +#15039 = DIRECTION('',(0.,1.)); +#15040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15041 = ORIENTED_EDGE('',*,*,#15042,.T.); +#15042 = EDGE_CURVE('',#15015,#15015,#15043,.T.); +#15043 = SURFACE_CURVE('',#15044,(#15049,#15056),.PCURVE_S1.); +#15044 = CIRCLE('',#15045,1.05); +#15045 = AXIS2_PLACEMENT_3D('',#15046,#15047,#15048); +#15046 = CARTESIAN_POINT('',(-32.99999999994,-46.29999999999,33.4)); +#15047 = DIRECTION('',(1.,6.704039033313E-15,-6.698566774573E-29)); +#15048 = DIRECTION('',(-6.704039033313E-15,1.,-1.224646799147E-16)); +#15049 = PCURVE('',#15023,#15050); +#15050 = DEFINITIONAL_REPRESENTATION('',(#15051),#15055); +#15051 = LINE('',#15052,#15053); +#15052 = CARTESIAN_POINT('',(12.566370614359,7.5)); +#15053 = VECTOR('',#15054,1.); +#15054 = DIRECTION('',(-1.,0.)); +#15055 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15056 = PCURVE('',#3447,#15057); +#15057 = DEFINITIONAL_REPRESENTATION('',(#15058),#15062); +#15058 = CIRCLE('',#15059,1.05); +#15059 = AXIS2_PLACEMENT_2D('',#15060,#15061); +#15060 = CARTESIAN_POINT('',(5.1,18.300000000025)); +#15061 = DIRECTION('',(-2.242250670306E-16,1.)); +#15062 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15063 = ORIENTED_EDGE('',*,*,#15012,.F.); +#15064 = ORIENTED_EDGE('',*,*,#15065,.T.); +#15065 = EDGE_CURVE('',#15013,#15013,#15066,.T.); +#15066 = SURFACE_CURVE('',#15067,(#15072,#15079),.PCURVE_S1.); +#15067 = CIRCLE('',#15068,1.05); +#15068 = AXIS2_PLACEMENT_3D('',#15069,#15070,#15071); +#15069 = CARTESIAN_POINT('',(-25.49999999994,-46.29999999999,33.4)); +#15070 = DIRECTION('',(-1.,-6.459479416001E-15,6.695571783048E-29)); +#15071 = DIRECTION('',(-6.459479416001E-15,1.,-1.224646799147E-16)); +#15072 = PCURVE('',#15023,#15073); +#15073 = DEFINITIONAL_REPRESENTATION('',(#15074),#15078); +#15074 = LINE('',#15075,#15076); +#15075 = CARTESIAN_POINT('',(0.,-9.947598300641E-14)); +#15076 = VECTOR('',#15077,1.); +#15077 = DIRECTION('',(1.,0.)); +#15078 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15079 = PCURVE('',#3814,#15080); +#15080 = DEFINITIONAL_REPRESENTATION('',(#15081),#15089); +#15081 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15082,#15083,#15084,#15085 + ,#15086,#15087,#15088),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15082 = CARTESIAN_POINT('',(-28.9,-6.65)); +#15083 = CARTESIAN_POINT('',(-27.08134665205,-6.65)); +#15084 = CARTESIAN_POINT('',(-27.99067332602,-8.225)); +#15085 = CARTESIAN_POINT('',(-28.9,-9.8)); +#15086 = CARTESIAN_POINT('',(-29.80932667397,-8.225)); +#15087 = CARTESIAN_POINT('',(-30.71865334794,-6.65)); +#15088 = CARTESIAN_POINT('',(-28.9,-6.65)); +#15089 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15090 = ADVANCED_FACE('',(#15091),#15105,.F.); +#15091 = FACE_BOUND('',#15092,.F.); +#15092 = EDGE_LOOP('',(#15093,#15123,#15145,#15146)); +#15093 = ORIENTED_EDGE('',*,*,#15094,.T.); +#15094 = EDGE_CURVE('',#15095,#15097,#15099,.T.); +#15095 = VERTEX_POINT('',#15096); +#15096 = CARTESIAN_POINT('',(-25.49999999994,-47.34999999999,7.6)); +#15097 = VERTEX_POINT('',#15098); +#15098 = CARTESIAN_POINT('',(-32.99999999994,-47.34999999999,7.6)); +#15099 = SEAM_CURVE('',#15100,(#15104,#15116),.PCURVE_S1.); +#15100 = LINE('',#15101,#15102); +#15101 = CARTESIAN_POINT('',(-25.49999999994,-47.34999999999,7.6)); +#15102 = VECTOR('',#15103,1.); +#15103 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15104 = PCURVE('',#15105,#15110); +#15105 = CYLINDRICAL_SURFACE('',#15106,1.05); +#15106 = AXIS2_PLACEMENT_3D('',#15107,#15108,#15109); +#15107 = CARTESIAN_POINT('',(-25.49999999994,-46.29999999999,7.6)); +#15108 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15109 = DIRECTION('',(-4.864065825301E-15,1.,-1.224646799147E-16)); +#15110 = DEFINITIONAL_REPRESENTATION('',(#15111),#15115); +#15111 = LINE('',#15112,#15113); +#15112 = CARTESIAN_POINT('',(9.424777960769,7.105427357601E-15)); +#15113 = VECTOR('',#15114,1.); +#15114 = DIRECTION('',(0.,1.)); +#15115 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15116 = PCURVE('',#15105,#15117); +#15117 = DEFINITIONAL_REPRESENTATION('',(#15118),#15122); +#15118 = LINE('',#15119,#15120); +#15119 = CARTESIAN_POINT('',(3.14159265359,7.105427357601E-15)); +#15120 = VECTOR('',#15121,1.); +#15121 = DIRECTION('',(0.,1.)); +#15122 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15123 = ORIENTED_EDGE('',*,*,#15124,.T.); +#15124 = EDGE_CURVE('',#15097,#15097,#15125,.T.); +#15125 = SURFACE_CURVE('',#15126,(#15131,#15138),.PCURVE_S1.); +#15126 = CIRCLE('',#15127,1.05); +#15127 = AXIS2_PLACEMENT_3D('',#15128,#15129,#15130); +#15128 = CARTESIAN_POINT('',(-32.99999999994,-46.29999999999,7.6)); +#15129 = DIRECTION('',(1.,6.704039033313E-15,-6.698566774573E-29)); +#15130 = DIRECTION('',(-6.704039033313E-15,1.,-1.224646799147E-16)); +#15131 = PCURVE('',#15105,#15132); +#15132 = DEFINITIONAL_REPRESENTATION('',(#15133),#15137); +#15133 = LINE('',#15134,#15135); +#15134 = CARTESIAN_POINT('',(12.566370614359,7.5)); +#15135 = VECTOR('',#15136,1.); +#15136 = DIRECTION('',(-1.,0.)); +#15137 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15138 = PCURVE('',#3447,#15139); +#15139 = DEFINITIONAL_REPRESENTATION('',(#15140),#15144); +#15140 = CIRCLE('',#15141,1.05); +#15141 = AXIS2_PLACEMENT_2D('',#15142,#15143); +#15142 = CARTESIAN_POINT('',(30.9,18.300000000025)); +#15143 = DIRECTION('',(-2.242250670306E-16,1.)); +#15144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15145 = ORIENTED_EDGE('',*,*,#15094,.F.); +#15146 = ORIENTED_EDGE('',*,*,#15147,.T.); +#15147 = EDGE_CURVE('',#15095,#15095,#15148,.T.); +#15148 = SURFACE_CURVE('',#15149,(#15154,#15161),.PCURVE_S1.); +#15149 = CIRCLE('',#15150,1.05); +#15150 = AXIS2_PLACEMENT_3D('',#15151,#15152,#15153); +#15151 = CARTESIAN_POINT('',(-25.49999999994,-46.29999999999,7.6)); +#15152 = DIRECTION('',(-1.,-6.459479416001E-15,6.695571783048E-29)); +#15153 = DIRECTION('',(-6.459479416001E-15,1.,-1.224646799147E-16)); +#15154 = PCURVE('',#15105,#15155); +#15155 = DEFINITIONAL_REPRESENTATION('',(#15156),#15160); +#15156 = LINE('',#15157,#15158); +#15157 = CARTESIAN_POINT('',(0.,-9.947598300641E-14)); +#15158 = VECTOR('',#15159,1.); +#15159 = DIRECTION('',(1.,0.)); +#15160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15161 = PCURVE('',#3814,#15162); +#15162 = DEFINITIONAL_REPRESENTATION('',(#15163),#15171); +#15163 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15164,#15165,#15166,#15167 + ,#15168,#15169,#15170),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15164 = CARTESIAN_POINT('',(-3.1,-6.65)); +#15165 = CARTESIAN_POINT('',(-1.281346652053,-6.65)); +#15166 = CARTESIAN_POINT('',(-2.190673326026,-8.225)); +#15167 = CARTESIAN_POINT('',(-3.1,-9.8)); +#15168 = CARTESIAN_POINT('',(-4.009326673974,-8.225)); +#15169 = CARTESIAN_POINT('',(-4.918653347947,-6.65)); +#15170 = CARTESIAN_POINT('',(-3.1,-6.65)); +#15171 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15172 = ADVANCED_FACE('',(#15173),#15187,.F.); +#15173 = FACE_BOUND('',#15174,.F.); +#15174 = EDGE_LOOP('',(#15175,#15205,#15227,#15228)); +#15175 = ORIENTED_EDGE('',*,*,#15176,.T.); +#15176 = EDGE_CURVE('',#15177,#15179,#15181,.T.); +#15177 = VERTEX_POINT('',#15178); +#15178 = CARTESIAN_POINT('',(-25.49999999994,-57.94999999999,7.6)); +#15179 = VERTEX_POINT('',#15180); +#15180 = CARTESIAN_POINT('',(-32.99999999994,-57.94999999999,7.6)); +#15181 = SEAM_CURVE('',#15182,(#15186,#15198),.PCURVE_S1.); +#15182 = LINE('',#15183,#15184); +#15183 = CARTESIAN_POINT('',(-25.49999999994,-57.94999999999,7.6)); +#15184 = VECTOR('',#15185,1.); +#15185 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15186 = PCURVE('',#15187,#15192); +#15187 = CYLINDRICAL_SURFACE('',#15188,1.05); +#15188 = AXIS2_PLACEMENT_3D('',#15189,#15190,#15191); +#15189 = CARTESIAN_POINT('',(-25.49999999994,-56.89999999999,7.6)); +#15190 = DIRECTION('',(-1.,-4.864065825301E-15,6.676033601576E-29)); +#15191 = DIRECTION('',(-4.864065825301E-15,1.,-1.224646799147E-16)); +#15192 = DEFINITIONAL_REPRESENTATION('',(#15193),#15197); +#15193 = LINE('',#15194,#15195); +#15194 = CARTESIAN_POINT('',(9.424777960769,-9.592326932761E-14)); +#15195 = VECTOR('',#15196,1.); +#15196 = DIRECTION('',(0.,1.)); +#15197 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15198 = PCURVE('',#15187,#15199); +#15199 = DEFINITIONAL_REPRESENTATION('',(#15200),#15204); +#15200 = LINE('',#15201,#15202); +#15201 = CARTESIAN_POINT('',(3.14159265359,-9.592326932761E-14)); +#15202 = VECTOR('',#15203,1.); +#15203 = DIRECTION('',(0.,1.)); +#15204 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15205 = ORIENTED_EDGE('',*,*,#15206,.T.); +#15206 = EDGE_CURVE('',#15179,#15179,#15207,.T.); +#15207 = SURFACE_CURVE('',#15208,(#15213,#15220),.PCURVE_S1.); +#15208 = CIRCLE('',#15209,1.05); +#15209 = AXIS2_PLACEMENT_3D('',#15210,#15211,#15212); +#15210 = CARTESIAN_POINT('',(-32.99999999994,-56.89999999999,7.6)); +#15211 = DIRECTION('',(1.,6.704039033313E-15,-6.698566774573E-29)); +#15212 = DIRECTION('',(-6.704039033313E-15,1.,-1.224646799147E-16)); +#15213 = PCURVE('',#15187,#15214); +#15214 = DEFINITIONAL_REPRESENTATION('',(#15215),#15219); +#15215 = LINE('',#15216,#15217); +#15216 = CARTESIAN_POINT('',(12.566370614359,7.5)); +#15217 = VECTOR('',#15218,1.); +#15218 = DIRECTION('',(-1.,0.)); +#15219 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15220 = PCURVE('',#3447,#15221); +#15221 = DEFINITIONAL_REPRESENTATION('',(#15222),#15226); +#15222 = CIRCLE('',#15223,1.05); +#15223 = AXIS2_PLACEMENT_2D('',#15224,#15225); +#15224 = CARTESIAN_POINT('',(30.9,7.700000000025)); +#15225 = DIRECTION('',(-2.242250670306E-16,1.)); +#15226 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15227 = ORIENTED_EDGE('',*,*,#15176,.F.); +#15228 = ORIENTED_EDGE('',*,*,#15229,.T.); +#15229 = EDGE_CURVE('',#15177,#15177,#15230,.T.); +#15230 = SURFACE_CURVE('',#15231,(#15236,#15243),.PCURVE_S1.); +#15231 = CIRCLE('',#15232,1.05); +#15232 = AXIS2_PLACEMENT_3D('',#15233,#15234,#15235); +#15233 = CARTESIAN_POINT('',(-25.49999999994,-56.89999999999,7.6)); +#15234 = DIRECTION('',(-1.,-6.459479416001E-15,6.695571783048E-29)); +#15235 = DIRECTION('',(-6.459479416001E-15,1.,-1.224646799147E-16)); +#15236 = PCURVE('',#15187,#15237); +#15237 = DEFINITIONAL_REPRESENTATION('',(#15238),#15242); +#15238 = LINE('',#15239,#15240); +#15239 = CARTESIAN_POINT('',(0.,-1.030286966852E-13)); +#15240 = VECTOR('',#15241,1.); +#15241 = DIRECTION('',(1.,0.)); +#15242 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15243 = PCURVE('',#3814,#15244); +#15244 = DEFINITIONAL_REPRESENTATION('',(#15245),#15253); +#15245 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15246,#15247,#15248,#15249 + ,#15250,#15251,#15252),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15246 = CARTESIAN_POINT('',(-3.1,-17.25)); +#15247 = CARTESIAN_POINT('',(-1.281346652053,-17.25)); +#15248 = CARTESIAN_POINT('',(-2.190673326026,-18.825)); +#15249 = CARTESIAN_POINT('',(-3.1,-20.4)); +#15250 = CARTESIAN_POINT('',(-4.009326673974,-18.825)); +#15251 = CARTESIAN_POINT('',(-4.918653347947,-17.25)); +#15252 = CARTESIAN_POINT('',(-3.1,-17.25)); +#15253 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15254 = ADVANCED_FACE('',(#15255),#5104,.F.); +#15255 = FACE_BOUND('',#15256,.F.); +#15256 = EDGE_LOOP('',(#15257,#15280,#15311,#15312)); +#15257 = ORIENTED_EDGE('',*,*,#15258,.T.); +#15258 = EDGE_CURVE('',#5084,#15259,#15261,.T.); +#15259 = VERTEX_POINT('',#15260); +#15260 = CARTESIAN_POINT('',(-38.99999999995,-33.60000000001,7.)); +#15261 = SEAM_CURVE('',#15262,(#15266,#15273),.PCURVE_S1.); +#15262 = LINE('',#15263,#15264); +#15263 = CARTESIAN_POINT('',(-38.99999999995,-35.60000000001,7.)); +#15264 = VECTOR('',#15265,1.); +#15265 = DIRECTION('',(-7.93809462607E-13,1.,-1.224646799147E-16)); +#15266 = PCURVE('',#5104,#15267); +#15267 = DEFINITIONAL_REPRESENTATION('',(#15268),#15272); +#15268 = LINE('',#15269,#15270); +#15269 = CARTESIAN_POINT('',(9.424777960769,-1.42108547152E-14)); +#15270 = VECTOR('',#15271,1.); +#15271 = DIRECTION('',(0.,1.)); +#15272 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15273 = PCURVE('',#5104,#15274); +#15274 = DEFINITIONAL_REPRESENTATION('',(#15275),#15279); +#15275 = LINE('',#15276,#15277); +#15276 = CARTESIAN_POINT('',(3.14159265359,-1.42108547152E-14)); +#15277 = VECTOR('',#15278,1.); +#15278 = DIRECTION('',(0.,1.)); +#15279 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15280 = ORIENTED_EDGE('',*,*,#15281,.F.); +#15281 = EDGE_CURVE('',#15259,#15259,#15282,.T.); +#15282 = SURFACE_CURVE('',#15283,(#15288,#15295),.PCURVE_S1.); +#15283 = CIRCLE('',#15284,2.); +#15284 = AXIS2_PLACEMENT_3D('',#15285,#15286,#15287); +#15285 = CARTESIAN_POINT('',(-36.99999999995,-33.60000000001,7.)); +#15286 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#15287 = DIRECTION('',(1.,7.938040362974E-13,-1.633855859806E-28)); +#15288 = PCURVE('',#5104,#15289); +#15289 = DEFINITIONAL_REPRESENTATION('',(#15290),#15294); +#15290 = LINE('',#15291,#15292); +#15291 = CARTESIAN_POINT('',(0.,2.)); +#15292 = VECTOR('',#15293,1.); +#15293 = DIRECTION('',(1.,0.)); +#15294 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15295 = PCURVE('',#15296,#15301); +#15296 = PLANE('',#15297); +#15297 = AXIS2_PLACEMENT_3D('',#15298,#15299,#15300); +#15298 = CARTESIAN_POINT('',(-54.89999999996,-33.60000000002,21.5)); +#15299 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15300 = DIRECTION('',(-6.616465975138E-29,-1.112809542387E-15,-1.)); +#15301 = DEFINITIONAL_REPRESENTATION('',(#15302),#15310); +#15302 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15303,#15304,#15305,#15306 + ,#15307,#15308,#15309),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15303 = CARTESIAN_POINT('',(14.5,19.90000000001)); +#15304 = CARTESIAN_POINT('',(17.964101615138,19.90000000001)); +#15305 = CARTESIAN_POINT('',(16.232050807569,16.90000000001)); +#15306 = CARTESIAN_POINT('',(14.5,13.90000000001)); +#15307 = CARTESIAN_POINT('',(12.767949192431,16.90000000001)); +#15308 = CARTESIAN_POINT('',(11.035898384862,19.90000000001)); +#15309 = CARTESIAN_POINT('',(14.5,19.90000000001)); +#15310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15311 = ORIENTED_EDGE('',*,*,#15258,.F.); +#15312 = ORIENTED_EDGE('',*,*,#5083,.T.); +#15313 = ADVANCED_FACE('',(#15314,#15317),#15296,.T.); +#15314 = FACE_BOUND('',#15315,.T.); +#15315 = EDGE_LOOP('',(#15316)); +#15316 = ORIENTED_EDGE('',*,*,#15281,.F.); +#15317 = FACE_BOUND('',#15318,.T.); +#15318 = EDGE_LOOP('',(#15319)); +#15319 = ORIENTED_EDGE('',*,*,#15320,.F.); +#15320 = EDGE_CURVE('',#15321,#15321,#15323,.T.); +#15321 = VERTEX_POINT('',#15322); +#15322 = CARTESIAN_POINT('',(-38.04999999995,-33.60000000001,7.)); +#15323 = SURFACE_CURVE('',#15324,(#15329,#15336),.PCURVE_S1.); +#15324 = CIRCLE('',#15325,1.05); +#15325 = AXIS2_PLACEMENT_3D('',#15326,#15327,#15328); +#15326 = CARTESIAN_POINT('',(-36.99999999995,-33.60000000001,7.)); +#15327 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15328 = DIRECTION('',(1.,7.938040362974E-13,-1.631659542442E-28)); +#15329 = PCURVE('',#15296,#15330); +#15330 = DEFINITIONAL_REPRESENTATION('',(#15331),#15335); +#15331 = CIRCLE('',#15332,1.05); +#15332 = AXIS2_PLACEMENT_2D('',#15333,#15334); +#15333 = CARTESIAN_POINT('',(14.5,17.90000000001)); +#15334 = DIRECTION('',(-7.863514118841E-28,1.)); +#15335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15336 = PCURVE('',#5958,#15337); +#15337 = DEFINITIONAL_REPRESENTATION('',(#15338),#15342); +#15338 = LINE('',#15339,#15340); +#15339 = CARTESIAN_POINT('',(0.,3.3)); +#15340 = VECTOR('',#15341,1.); +#15341 = DIRECTION('',(1.,0.)); +#15342 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15343 = ADVANCED_FACE('',(#15344),#5139,.F.); +#15344 = FACE_BOUND('',#15345,.F.); +#15345 = EDGE_LOOP('',(#15346,#15369,#15400,#15401)); +#15346 = ORIENTED_EDGE('',*,*,#15347,.T.); +#15347 = EDGE_CURVE('',#5119,#15348,#15350,.T.); +#15348 = VERTEX_POINT('',#15349); +#15349 = CARTESIAN_POINT('',(-74.79999999997,-33.60000000004,7.)); +#15350 = SEAM_CURVE('',#15351,(#15355,#15362),.PCURVE_S1.); +#15351 = LINE('',#15352,#15353); +#15352 = CARTESIAN_POINT('',(-74.79999999997,-35.60000000004,7.)); +#15353 = VECTOR('',#15354,1.); +#15354 = DIRECTION('',(-7.926992395824E-13,1.,-1.224646799147E-16)); +#15355 = PCURVE('',#5139,#15356); +#15356 = DEFINITIONAL_REPRESENTATION('',(#15357),#15361); +#15357 = LINE('',#15358,#15359); +#15358 = CARTESIAN_POINT('',(9.424777960769,-2.13162820728E-14)); +#15359 = VECTOR('',#15360,1.); +#15360 = DIRECTION('',(0.,1.)); +#15361 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15362 = PCURVE('',#5139,#15363); +#15363 = DEFINITIONAL_REPRESENTATION('',(#15364),#15368); +#15364 = LINE('',#15365,#15366); +#15365 = CARTESIAN_POINT('',(3.14159265359,-2.13162820728E-14)); +#15366 = VECTOR('',#15367,1.); +#15367 = DIRECTION('',(0.,1.)); +#15368 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15369 = ORIENTED_EDGE('',*,*,#15370,.F.); +#15370 = EDGE_CURVE('',#15348,#15348,#15371,.T.); +#15371 = SURFACE_CURVE('',#15372,(#15377,#15384),.PCURVE_S1.); +#15372 = CIRCLE('',#15373,2.); +#15373 = AXIS2_PLACEMENT_3D('',#15374,#15375,#15376); +#15374 = CARTESIAN_POINT('',(-72.79999999997,-33.60000000003,7.)); +#15375 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#15376 = DIRECTION('',(1.,7.938040362974E-13,-1.633348244831E-28)); +#15377 = PCURVE('',#5139,#15378); +#15378 = DEFINITIONAL_REPRESENTATION('',(#15379),#15383); +#15379 = LINE('',#15380,#15381); +#15380 = CARTESIAN_POINT('',(0.,2.)); +#15381 = VECTOR('',#15382,1.); +#15382 = DIRECTION('',(1.,0.)); +#15383 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15384 = PCURVE('',#15385,#15390); +#15385 = PLANE('',#15386); +#15386 = AXIS2_PLACEMENT_3D('',#15387,#15388,#15389); +#15387 = CARTESIAN_POINT('',(-54.89999999996,-33.60000000002,21.5)); +#15388 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15389 = DIRECTION('',(-6.616465975138E-29,-1.112809542387E-15,-1.)); +#15390 = DEFINITIONAL_REPRESENTATION('',(#15391),#15399); +#15391 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15392,#15393,#15394,#15395 + ,#15396,#15397,#15398),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15392 = CARTESIAN_POINT('',(14.5,-15.90000000001)); +#15393 = CARTESIAN_POINT('',(17.964101615138,-15.90000000001)); +#15394 = CARTESIAN_POINT('',(16.232050807569,-18.90000000001)); +#15395 = CARTESIAN_POINT('',(14.5,-21.90000000001)); +#15396 = CARTESIAN_POINT('',(12.767949192431,-18.90000000001)); +#15397 = CARTESIAN_POINT('',(11.035898384862,-15.90000000001)); +#15398 = CARTESIAN_POINT('',(14.5,-15.90000000001)); +#15399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15400 = ORIENTED_EDGE('',*,*,#15347,.F.); +#15401 = ORIENTED_EDGE('',*,*,#5118,.T.); +#15402 = ADVANCED_FACE('',(#15403,#15406),#15385,.T.); +#15403 = FACE_BOUND('',#15404,.T.); +#15404 = EDGE_LOOP('',(#15405)); +#15405 = ORIENTED_EDGE('',*,*,#15370,.F.); +#15406 = FACE_BOUND('',#15407,.T.); +#15407 = EDGE_LOOP('',(#15408)); +#15408 = ORIENTED_EDGE('',*,*,#15409,.F.); +#15409 = EDGE_CURVE('',#15410,#15410,#15412,.T.); +#15410 = VERTEX_POINT('',#15411); +#15411 = CARTESIAN_POINT('',(-73.84999999997,-33.60000000003,7.)); +#15412 = SURFACE_CURVE('',#15413,(#15418,#15425),.PCURVE_S1.); +#15413 = CIRCLE('',#15414,1.05); +#15414 = AXIS2_PLACEMENT_3D('',#15415,#15416,#15417); +#15415 = CARTESIAN_POINT('',(-72.79999999997,-33.60000000003,7.)); +#15416 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15417 = DIRECTION('',(1.,7.938040362974E-13,-1.631659542442E-28)); +#15418 = PCURVE('',#15385,#15419); +#15419 = DEFINITIONAL_REPRESENTATION('',(#15420),#15424); +#15420 = CIRCLE('',#15421,1.05); +#15421 = AXIS2_PLACEMENT_2D('',#15422,#15423); +#15422 = CARTESIAN_POINT('',(14.5,-17.90000000001)); +#15423 = DIRECTION('',(-7.863514118841E-28,1.)); +#15424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15425 = PCURVE('',#5923,#15426); +#15426 = DEFINITIONAL_REPRESENTATION('',(#15427),#15431); +#15427 = LINE('',#15428,#15429); +#15428 = CARTESIAN_POINT('',(0.,3.3)); +#15429 = VECTOR('',#15430,1.); +#15430 = DIRECTION('',(1.,0.)); +#15431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15432 = ADVANCED_FACE('',(#15433),#5174,.F.); +#15433 = FACE_BOUND('',#15434,.F.); +#15434 = EDGE_LOOP('',(#15435,#15458,#15489,#15490)); +#15435 = ORIENTED_EDGE('',*,*,#15436,.T.); +#15436 = EDGE_CURVE('',#5154,#15437,#15439,.T.); +#15437 = VERTEX_POINT('',#15438); +#15438 = CARTESIAN_POINT('',(-74.79999999997,-33.60000000004,36.)); +#15439 = SEAM_CURVE('',#15440,(#15444,#15451),.PCURVE_S1.); +#15440 = LINE('',#15441,#15442); +#15441 = CARTESIAN_POINT('',(-74.79999999997,-35.60000000004,36.)); +#15442 = VECTOR('',#15443,1.); +#15443 = DIRECTION('',(-7.926992395824E-13,1.,-1.224646799147E-16)); +#15444 = PCURVE('',#5174,#15445); +#15445 = DEFINITIONAL_REPRESENTATION('',(#15446),#15450); +#15446 = LINE('',#15447,#15448); +#15447 = CARTESIAN_POINT('',(9.424777960769,7.815970093361E-14)); +#15448 = VECTOR('',#15449,1.); +#15449 = DIRECTION('',(0.,1.)); +#15450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15451 = PCURVE('',#5174,#15452); +#15452 = DEFINITIONAL_REPRESENTATION('',(#15453),#15457); +#15453 = LINE('',#15454,#15455); +#15454 = CARTESIAN_POINT('',(3.14159265359,7.815970093361E-14)); +#15455 = VECTOR('',#15456,1.); +#15456 = DIRECTION('',(0.,1.)); +#15457 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15458 = ORIENTED_EDGE('',*,*,#15459,.F.); +#15459 = EDGE_CURVE('',#15437,#15437,#15460,.T.); +#15460 = SURFACE_CURVE('',#15461,(#15466,#15473),.PCURVE_S1.); +#15461 = CIRCLE('',#15462,2.); +#15462 = AXIS2_PLACEMENT_3D('',#15463,#15464,#15465); +#15463 = CARTESIAN_POINT('',(-72.79999999997,-33.60000000003,36.)); +#15464 = DIRECTION('',(-7.938040362974E-13,1.,-1.112809542387E-15)); +#15465 = DIRECTION('',(1.,7.938040362974E-13,-1.633348244831E-28)); +#15466 = PCURVE('',#5174,#15467); +#15467 = DEFINITIONAL_REPRESENTATION('',(#15468),#15472); +#15468 = LINE('',#15469,#15470); +#15469 = CARTESIAN_POINT('',(0.,2.)); +#15470 = VECTOR('',#15471,1.); +#15471 = DIRECTION('',(1.,0.)); +#15472 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15473 = PCURVE('',#15474,#15479); +#15474 = PLANE('',#15475); +#15475 = AXIS2_PLACEMENT_3D('',#15476,#15477,#15478); +#15476 = CARTESIAN_POINT('',(-54.89999999996,-33.60000000002,21.5)); +#15477 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15478 = DIRECTION('',(-6.616465975138E-29,-1.112809542387E-15,-1.)); +#15479 = DEFINITIONAL_REPRESENTATION('',(#15480),#15488); +#15480 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15481,#15482,#15483,#15484 + ,#15485,#15486,#15487),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15481 = CARTESIAN_POINT('',(-14.5,-15.90000000001)); +#15482 = CARTESIAN_POINT('',(-11.03589838486,-15.90000000001)); +#15483 = CARTESIAN_POINT('',(-12.76794919243,-18.90000000001)); +#15484 = CARTESIAN_POINT('',(-14.5,-21.90000000001)); +#15485 = CARTESIAN_POINT('',(-16.23205080756,-18.90000000001)); +#15486 = CARTESIAN_POINT('',(-17.96410161513,-15.90000000001)); +#15487 = CARTESIAN_POINT('',(-14.5,-15.90000000001)); +#15488 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15489 = ORIENTED_EDGE('',*,*,#15436,.F.); +#15490 = ORIENTED_EDGE('',*,*,#5153,.T.); +#15491 = ADVANCED_FACE('',(#15492,#15495),#15474,.T.); +#15492 = FACE_BOUND('',#15493,.T.); +#15493 = EDGE_LOOP('',(#15494)); +#15494 = ORIENTED_EDGE('',*,*,#15459,.F.); +#15495 = FACE_BOUND('',#15496,.T.); +#15496 = EDGE_LOOP('',(#15497)); +#15497 = ORIENTED_EDGE('',*,*,#15498,.F.); +#15498 = EDGE_CURVE('',#15499,#15499,#15501,.T.); +#15499 = VERTEX_POINT('',#15500); +#15500 = CARTESIAN_POINT('',(-73.84999999997,-33.60000000003,36.)); +#15501 = SURFACE_CURVE('',#15502,(#15507,#15514),.PCURVE_S1.); +#15502 = CIRCLE('',#15503,1.05); +#15503 = AXIS2_PLACEMENT_3D('',#15504,#15505,#15506); +#15504 = CARTESIAN_POINT('',(-72.79999999997,-33.60000000003,36.)); +#15505 = DIRECTION('',(7.938040362974E-13,-1.,1.112809542387E-15)); +#15506 = DIRECTION('',(1.,7.938040362974E-13,-1.631659542442E-28)); +#15507 = PCURVE('',#15474,#15508); +#15508 = DEFINITIONAL_REPRESENTATION('',(#15509),#15513); +#15509 = CIRCLE('',#15510,1.05); +#15510 = AXIS2_PLACEMENT_2D('',#15511,#15512); +#15511 = CARTESIAN_POINT('',(-14.5,-17.90000000001)); +#15512 = DIRECTION('',(-7.863514118841E-28,1.)); +#15513 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15514 = PCURVE('',#5993,#15515); +#15515 = DEFINITIONAL_REPRESENTATION('',(#15516),#15520); +#15516 = LINE('',#15517,#15518); +#15517 = CARTESIAN_POINT('',(-6.28318530718,3.3)); +#15518 = VECTOR('',#15519,1.); +#15519 = DIRECTION('',(1.,0.)); +#15520 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15521 = ADVANCED_FACE('',(#15522),#5047,.T.); +#15522 = FACE_BOUND('',#15523,.T.); +#15523 = EDGE_LOOP('',(#15524,#15525,#15546,#15547)); +#15524 = ORIENTED_EDGE('',*,*,#5854,.T.); +#15525 = ORIENTED_EDGE('',*,*,#15526,.T.); +#15526 = EDGE_CURVE('',#5832,#5032,#15527,.T.); +#15527 = SURFACE_CURVE('',#15528,(#15532,#15539),.PCURVE_S1.); +#15528 = LINE('',#15529,#15530); +#15529 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,38.5)); +#15530 = VECTOR('',#15531,1.); +#15531 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#15532 = PCURVE('',#5047,#15533); +#15533 = DEFINITIONAL_REPRESENTATION('',(#15534),#15538); +#15534 = LINE('',#15535,#15536); +#15535 = CARTESIAN_POINT('',(42.950000000024,5.062530134941E-15)); +#15536 = VECTOR('',#15537,1.); +#15537 = DIRECTION('',(3.087877539851E-16,1.)); +#15538 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15539 = PCURVE('',#3649,#15540); +#15540 = DEFINITIONAL_REPRESENTATION('',(#15541),#15545); +#15541 = LINE('',#15542,#15543); +#15542 = CARTESIAN_POINT('',(0.,0.)); +#15543 = VECTOR('',#15544,1.); +#15544 = DIRECTION('',(-6.854634765848E-16,1.)); +#15545 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15546 = ORIENTED_EDGE('',*,*,#5031,.F.); +#15547 = ORIENTED_EDGE('',*,*,#15548,.F.); +#15548 = EDGE_CURVE('',#5855,#4999,#15549,.T.); +#15549 = SURFACE_CURVE('',#15550,(#15554,#15561),.PCURVE_S1.); +#15550 = LINE('',#15551,#15552); +#15551 = CARTESIAN_POINT('',(-34.00685424944,-30.3,38.5)); +#15552 = VECTOR('',#15553,1.); +#15553 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#15554 = PCURVE('',#5047,#15555); +#15555 = DEFINITIONAL_REPRESENTATION('',(#15556),#15560); +#15556 = LINE('',#15557,#15558); +#15557 = CARTESIAN_POINT('',(1.656854249492,-1.492438436264E-14)); +#15558 = VECTOR('',#15559,1.); +#15559 = DIRECTION('',(3.087877539851E-16,1.)); +#15560 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15561 = PCURVE('',#5019,#15562); +#15562 = DEFINITIONAL_REPRESENTATION('',(#15563),#15567); +#15563 = LINE('',#15564,#15565); +#15564 = CARTESIAN_POINT('',(0.392699081699,7.105427357601E-15)); +#15565 = VECTOR('',#15566,1.); +#15566 = DIRECTION('',(-1.776356839397E-16,1.)); +#15567 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15568 = ADVANCED_FACE('',(#15569),#3649,.T.); +#15569 = FACE_BOUND('',#15570,.T.); +#15570 = EDGE_LOOP('',(#15571,#15572,#15573,#15574)); +#15571 = ORIENTED_EDGE('',*,*,#5831,.T.); +#15572 = ORIENTED_EDGE('',*,*,#3633,.T.); +#15573 = ORIENTED_EDGE('',*,*,#5059,.F.); +#15574 = ORIENTED_EDGE('',*,*,#15526,.F.); +#15575 = ADVANCED_FACE('',(#15576),#5019,.T.); +#15576 = FACE_BOUND('',#15577,.T.); +#15577 = EDGE_LOOP('',(#15578,#15579,#15580,#15581)); +#15578 = ORIENTED_EDGE('',*,*,#5877,.T.); +#15579 = ORIENTED_EDGE('',*,*,#15548,.T.); +#15580 = ORIENTED_EDGE('',*,*,#4998,.T.); +#15581 = ORIENTED_EDGE('',*,*,#5802,.T.); +#15582 = ADVANCED_FACE('',(#15583),#5923,.F.); +#15583 = FACE_BOUND('',#15584,.F.); +#15584 = EDGE_LOOP('',(#15585,#15606,#15607,#15608)); +#15585 = ORIENTED_EDGE('',*,*,#15586,.T.); +#15586 = EDGE_CURVE('',#15410,#5903,#15587,.T.); +#15587 = SEAM_CURVE('',#15588,(#15592,#15599),.PCURVE_S1.); +#15588 = LINE('',#15589,#15590); +#15589 = CARTESIAN_POINT('',(-73.84999999997,-30.30000000003,7.)); +#15590 = VECTOR('',#15591,1.); +#15591 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#15592 = PCURVE('',#5923,#15593); +#15593 = DEFINITIONAL_REPRESENTATION('',(#15594),#15598); +#15594 = LINE('',#15595,#15596); +#15595 = CARTESIAN_POINT('',(3.14159265359,-3.19744231092E-14)); +#15596 = VECTOR('',#15597,1.); +#15597 = DIRECTION('',(0.,-1.)); +#15598 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15599 = PCURVE('',#5923,#15600); +#15600 = DEFINITIONAL_REPRESENTATION('',(#15601),#15605); +#15601 = LINE('',#15602,#15603); +#15602 = CARTESIAN_POINT('',(9.424777960769,-3.19744231092E-14)); +#15603 = VECTOR('',#15604,1.); +#15604 = DIRECTION('',(0.,-1.)); +#15605 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15606 = ORIENTED_EDGE('',*,*,#5902,.F.); +#15607 = ORIENTED_EDGE('',*,*,#15586,.F.); +#15608 = ORIENTED_EDGE('',*,*,#15409,.F.); +#15609 = ADVANCED_FACE('',(#15610),#5958,.F.); +#15610 = FACE_BOUND('',#15611,.F.); +#15611 = EDGE_LOOP('',(#15612,#15633,#15634,#15635)); +#15612 = ORIENTED_EDGE('',*,*,#15613,.T.); +#15613 = EDGE_CURVE('',#15321,#5938,#15614,.T.); +#15614 = SEAM_CURVE('',#15615,(#15619,#15626),.PCURVE_S1.); +#15615 = LINE('',#15616,#15617); +#15616 = CARTESIAN_POINT('',(-38.04999999995,-30.30000000001,7.)); +#15617 = VECTOR('',#15618,1.); +#15618 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#15619 = PCURVE('',#5958,#15620); +#15620 = DEFINITIONAL_REPRESENTATION('',(#15621),#15625); +#15621 = LINE('',#15622,#15623); +#15622 = CARTESIAN_POINT('',(3.14159265359,-3.19744231092E-14)); +#15623 = VECTOR('',#15624,1.); +#15624 = DIRECTION('',(0.,-1.)); +#15625 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15626 = PCURVE('',#5958,#15627); +#15627 = DEFINITIONAL_REPRESENTATION('',(#15628),#15632); +#15628 = LINE('',#15629,#15630); +#15629 = CARTESIAN_POINT('',(9.424777960769,-3.19744231092E-14)); +#15630 = VECTOR('',#15631,1.); +#15631 = DIRECTION('',(0.,-1.)); +#15632 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15633 = ORIENTED_EDGE('',*,*,#5937,.F.); +#15634 = ORIENTED_EDGE('',*,*,#15613,.F.); +#15635 = ORIENTED_EDGE('',*,*,#15320,.F.); +#15636 = ADVANCED_FACE('',(#15637),#5993,.F.); +#15637 = FACE_BOUND('',#15638,.F.); +#15638 = EDGE_LOOP('',(#15639,#15660,#15661,#15662)); +#15639 = ORIENTED_EDGE('',*,*,#15640,.T.); +#15640 = EDGE_CURVE('',#15499,#5973,#15641,.T.); +#15641 = SEAM_CURVE('',#15642,(#15646,#15653),.PCURVE_S1.); +#15642 = LINE('',#15643,#15644); +#15643 = CARTESIAN_POINT('',(-73.84999999997,-30.30000000003,36.)); +#15644 = VECTOR('',#15645,1.); +#15645 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#15646 = PCURVE('',#5993,#15647); +#15647 = DEFINITIONAL_REPRESENTATION('',(#15648),#15652); +#15648 = LINE('',#15649,#15650); +#15649 = CARTESIAN_POINT('',(-3.14159265359,-3.19744231092E-14)); +#15650 = VECTOR('',#15651,1.); +#15651 = DIRECTION('',(0.,-1.)); +#15652 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15653 = PCURVE('',#5993,#15654); +#15654 = DEFINITIONAL_REPRESENTATION('',(#15655),#15659); +#15655 = LINE('',#15656,#15657); +#15656 = CARTESIAN_POINT('',(3.14159265359,-3.19744231092E-14)); +#15657 = VECTOR('',#15658,1.); +#15658 = DIRECTION('',(0.,-1.)); +#15659 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15660 = ORIENTED_EDGE('',*,*,#5972,.F.); +#15661 = ORIENTED_EDGE('',*,*,#15640,.F.); +#15662 = ORIENTED_EDGE('',*,*,#15498,.F.); +#15663 = ADVANCED_FACE('',(#15664),#15678,.F.); +#15664 = FACE_BOUND('',#15665,.F.); +#15665 = EDGE_LOOP('',(#15666,#15696,#15727,#15728)); +#15666 = ORIENTED_EDGE('',*,*,#15667,.T.); +#15667 = EDGE_CURVE('',#15668,#15670,#15672,.T.); +#15668 = VERTEX_POINT('',#15669); +#15669 = CARTESIAN_POINT('',(-39.,35.600000000031,7.)); +#15670 = VERTEX_POINT('',#15671); +#15671 = CARTESIAN_POINT('',(-39.,33.600000000031,7.)); +#15672 = SEAM_CURVE('',#15673,(#15677,#15689),.PCURVE_S1.); +#15673 = LINE('',#15674,#15675); +#15674 = CARTESIAN_POINT('',(-39.,35.600000000031,7.)); +#15675 = VECTOR('',#15676,1.); +#15676 = DIRECTION('',(7.93809462607E-13,-1.,1.224646799147E-16)); +#15677 = PCURVE('',#15678,#15683); +#15678 = CYLINDRICAL_SURFACE('',#15679,2.); +#15679 = AXIS2_PLACEMENT_3D('',#15680,#15681,#15682); +#15680 = CARTESIAN_POINT('',(-37.,35.600000000033,7.)); +#15681 = DIRECTION('',(7.93809462607E-13,-1.,1.224646799147E-16)); +#15682 = DIRECTION('',(1.,7.93809462607E-13,-1.633783460705E-28)); +#15683 = DEFINITIONAL_REPRESENTATION('',(#15684),#15688); +#15684 = LINE('',#15685,#15686); +#15685 = CARTESIAN_POINT('',(9.424777960769,1.42108547152E-14)); +#15686 = VECTOR('',#15687,1.); +#15687 = DIRECTION('',(0.,1.)); +#15688 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15689 = PCURVE('',#15678,#15690); +#15690 = DEFINITIONAL_REPRESENTATION('',(#15691),#15695); +#15691 = LINE('',#15692,#15693); +#15692 = CARTESIAN_POINT('',(3.14159265359,1.42108547152E-14)); +#15693 = VECTOR('',#15694,1.); +#15694 = DIRECTION('',(0.,1.)); +#15695 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15696 = ORIENTED_EDGE('',*,*,#15697,.F.); +#15697 = EDGE_CURVE('',#15670,#15670,#15698,.T.); +#15698 = SURFACE_CURVE('',#15699,(#15704,#15711),.PCURVE_S1.); +#15699 = CIRCLE('',#15700,2.); +#15700 = AXIS2_PLACEMENT_3D('',#15701,#15702,#15703); +#15701 = CARTESIAN_POINT('',(-37.,33.600000000033,7.)); +#15702 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15703 = DIRECTION('',(1.,-7.174263050427E-13,1.314318610891E-27)); +#15704 = PCURVE('',#15678,#15705); +#15705 = DEFINITIONAL_REPRESENTATION('',(#15706),#15710); +#15706 = LINE('',#15707,#15708); +#15707 = CARTESIAN_POINT('',(0.,1.999999999997)); +#15708 = VECTOR('',#15709,1.); +#15709 = DIRECTION('',(1.,0.)); +#15710 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15711 = PCURVE('',#15712,#15717); +#15712 = PLANE('',#15713); +#15713 = AXIS2_PLACEMENT_3D('',#15714,#15715,#15716); +#15714 = CARTESIAN_POINT('',(-54.90000000001,33.600000000019,21.5)); +#15715 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#15716 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#15717 = DEFINITIONAL_REPRESENTATION('',(#15718),#15726); +#15718 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15719,#15720,#15721,#15722 + ,#15723,#15724,#15725),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15719 = CARTESIAN_POINT('',(-14.5,19.90000000001)); +#15720 = CARTESIAN_POINT('',(-11.03589838486,19.90000000001)); +#15721 = CARTESIAN_POINT('',(-12.76794919243,16.90000000001)); +#15722 = CARTESIAN_POINT('',(-14.5,13.90000000001)); +#15723 = CARTESIAN_POINT('',(-16.23205080756,16.90000000001)); +#15724 = CARTESIAN_POINT('',(-17.96410161513,19.90000000001)); +#15725 = CARTESIAN_POINT('',(-14.5,19.90000000001)); +#15726 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15727 = ORIENTED_EDGE('',*,*,#15667,.F.); +#15728 = ORIENTED_EDGE('',*,*,#15729,.T.); +#15729 = EDGE_CURVE('',#15668,#15668,#15730,.T.); +#15730 = SURFACE_CURVE('',#15731,(#15736,#15743),.PCURVE_S1.); +#15731 = CIRCLE('',#15732,2.); +#15732 = AXIS2_PLACEMENT_3D('',#15733,#15734,#15735); +#15733 = CARTESIAN_POINT('',(-37.,35.600000000024,7.)); +#15734 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15735 = DIRECTION('',(1.,-7.174263050427E-13,1.314323195916E-27)); +#15736 = PCURVE('',#15678,#15737); +#15737 = DEFINITIONAL_REPRESENTATION('',(#15738),#15742); +#15738 = LINE('',#15739,#15740); +#15739 = CARTESIAN_POINT('',(0.,5.584865903074E-12)); +#15740 = VECTOR('',#15741,1.); +#15741 = DIRECTION('',(1.,0.)); +#15742 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15743 = PCURVE('',#3040,#15744); +#15744 = DEFINITIONAL_REPRESENTATION('',(#15745),#15753); +#15745 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15746,#15747,#15748,#15749 + ,#15750,#15751,#15752),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15746 = CARTESIAN_POINT('',(-14.5,14.150000000001)); +#15747 = CARTESIAN_POINT('',(-11.03589838486,14.150000000001)); +#15748 = CARTESIAN_POINT('',(-12.76794919243,11.150000000001)); +#15749 = CARTESIAN_POINT('',(-14.5,8.150000000001)); +#15750 = CARTESIAN_POINT('',(-16.23205080756,11.150000000001)); +#15751 = CARTESIAN_POINT('',(-17.96410161513,14.150000000001)); +#15752 = CARTESIAN_POINT('',(-14.5,14.150000000001)); +#15753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15754 = ADVANCED_FACE('',(#15755,#15758),#15712,.T.); +#15755 = FACE_BOUND('',#15756,.T.); +#15756 = EDGE_LOOP('',(#15757)); +#15757 = ORIENTED_EDGE('',*,*,#15697,.F.); +#15758 = FACE_BOUND('',#15759,.T.); +#15759 = EDGE_LOOP('',(#15760)); +#15760 = ORIENTED_EDGE('',*,*,#15761,.F.); +#15761 = EDGE_CURVE('',#15762,#15762,#15764,.T.); +#15762 = VERTEX_POINT('',#15763); +#15763 = CARTESIAN_POINT('',(-38.05,33.600000000032,7.)); +#15764 = SURFACE_CURVE('',#15765,(#15770,#15777),.PCURVE_S1.); +#15765 = CIRCLE('',#15766,1.05); +#15766 = AXIS2_PLACEMENT_3D('',#15767,#15768,#15769); +#15767 = CARTESIAN_POINT('',(-37.,33.600000000033,7.)); +#15768 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#15769 = DIRECTION('',(1.,-7.174263050427E-13,1.314571968028E-27)); +#15770 = PCURVE('',#15712,#15771); +#15771 = DEFINITIONAL_REPRESENTATION('',(#15772),#15776); +#15772 = CIRCLE('',#15773,1.05); +#15773 = AXIS2_PLACEMENT_2D('',#15774,#15775); +#15774 = CARTESIAN_POINT('',(-14.5,17.90000000001)); +#15775 = DIRECTION('',(6.792299668617E-28,1.)); +#15776 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15777 = PCURVE('',#15778,#15783); +#15778 = CYLINDRICAL_SURFACE('',#15779,1.05); +#15779 = AXIS2_PLACEMENT_3D('',#15780,#15781,#15782); +#15780 = CARTESIAN_POINT('',(-36.99999999995,-30.30000000001,7.)); +#15781 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#15782 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#15783 = DEFINITIONAL_REPRESENTATION('',(#15784),#15788); +#15784 = LINE('',#15785,#15786); +#15785 = CARTESIAN_POINT('',(12.566370614359,-63.90000000004)); +#15786 = VECTOR('',#15787,1.); +#15787 = DIRECTION('',(-1.,0.)); +#15788 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15789 = ADVANCED_FACE('',(#15790),#15804,.F.); +#15790 = FACE_BOUND('',#15791,.F.); +#15791 = EDGE_LOOP('',(#15792,#15822,#15853,#15854)); +#15792 = ORIENTED_EDGE('',*,*,#15793,.T.); +#15793 = EDGE_CURVE('',#15794,#15796,#15798,.T.); +#15794 = VERTEX_POINT('',#15795); +#15795 = CARTESIAN_POINT('',(-74.80000000002,35.600000000003,7.)); +#15796 = VERTEX_POINT('',#15797); +#15797 = CARTESIAN_POINT('',(-74.80000000002,33.600000000003,7.)); +#15798 = SEAM_CURVE('',#15799,(#15803,#15815),.PCURVE_S1.); +#15799 = LINE('',#15800,#15801); +#15800 = CARTESIAN_POINT('',(-74.80000000002,35.600000000003,7.)); +#15801 = VECTOR('',#15802,1.); +#15802 = DIRECTION('',(7.926992395824E-13,-1.,1.224646799147E-16)); +#15803 = PCURVE('',#15804,#15809); +#15804 = CYLINDRICAL_SURFACE('',#15805,2.); +#15805 = AXIS2_PLACEMENT_3D('',#15806,#15807,#15808); +#15806 = CARTESIAN_POINT('',(-72.80000000002,35.600000000005,7.)); +#15807 = DIRECTION('',(7.926992395824E-13,-1.,1.224646799147E-16)); +#15808 = DIRECTION('',(1.,7.926992395824E-13,-1.632123585706E-28)); +#15809 = DEFINITIONAL_REPRESENTATION('',(#15810),#15814); +#15810 = LINE('',#15811,#15812); +#15811 = CARTESIAN_POINT('',(9.424777960769,1.42108547152E-14)); +#15812 = VECTOR('',#15813,1.); +#15813 = DIRECTION('',(0.,1.)); +#15814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15815 = PCURVE('',#15804,#15816); +#15816 = DEFINITIONAL_REPRESENTATION('',(#15817),#15821); +#15817 = LINE('',#15818,#15819); +#15818 = CARTESIAN_POINT('',(3.14159265359,1.42108547152E-14)); +#15819 = VECTOR('',#15820,1.); +#15820 = DIRECTION('',(0.,1.)); +#15821 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15822 = ORIENTED_EDGE('',*,*,#15823,.F.); +#15823 = EDGE_CURVE('',#15796,#15796,#15824,.T.); +#15824 = SURFACE_CURVE('',#15825,(#15830,#15837),.PCURVE_S1.); +#15825 = CIRCLE('',#15826,2.); +#15826 = AXIS2_PLACEMENT_3D('',#15827,#15828,#15829); +#15827 = CARTESIAN_POINT('',(-72.80000000002,33.600000000005,7.)); +#15828 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15829 = DIRECTION('',(1.,-7.174263050427E-13,1.314322435141E-27)); +#15830 = PCURVE('',#15804,#15831); +#15831 = DEFINITIONAL_REPRESENTATION('',(#15832),#15836); +#15832 = LINE('',#15833,#15834); +#15833 = CARTESIAN_POINT('',(0.,1.999999999997)); +#15834 = VECTOR('',#15835,1.); +#15835 = DIRECTION('',(1.,0.)); +#15836 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15837 = PCURVE('',#15838,#15843); +#15838 = PLANE('',#15839); +#15839 = AXIS2_PLACEMENT_3D('',#15840,#15841,#15842); +#15840 = CARTESIAN_POINT('',(-54.90000000001,33.600000000019,21.5)); +#15841 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#15842 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#15843 = DEFINITIONAL_REPRESENTATION('',(#15844),#15852); +#15844 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15845,#15846,#15847,#15848 + ,#15849,#15850,#15851),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15845 = CARTESIAN_POINT('',(-14.5,-15.90000000001)); +#15846 = CARTESIAN_POINT('',(-11.03589838486,-15.90000000001)); +#15847 = CARTESIAN_POINT('',(-12.76794919243,-18.90000000001)); +#15848 = CARTESIAN_POINT('',(-14.5,-21.90000000001)); +#15849 = CARTESIAN_POINT('',(-16.23205080756,-18.90000000001)); +#15850 = CARTESIAN_POINT('',(-17.96410161513,-15.90000000001)); +#15851 = CARTESIAN_POINT('',(-14.5,-15.90000000001)); +#15852 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15853 = ORIENTED_EDGE('',*,*,#15793,.F.); +#15854 = ORIENTED_EDGE('',*,*,#15855,.T.); +#15855 = EDGE_CURVE('',#15794,#15794,#15856,.T.); +#15856 = SURFACE_CURVE('',#15857,(#15862,#15869),.PCURVE_S1.); +#15857 = CIRCLE('',#15858,2.); +#15858 = AXIS2_PLACEMENT_3D('',#15859,#15860,#15861); +#15859 = CARTESIAN_POINT('',(-72.80000000002,35.599999999996,7.)); +#15860 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15861 = DIRECTION('',(1.,-7.174263050427E-13,1.313403596169E-27)); +#15862 = PCURVE('',#15804,#15863); +#15863 = DEFINITIONAL_REPRESENTATION('',(#15864),#15868); +#15864 = LINE('',#15865,#15866); +#15865 = CARTESIAN_POINT('',(0.,5.577760475717E-12)); +#15866 = VECTOR('',#15867,1.); +#15867 = DIRECTION('',(1.,0.)); +#15868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15869 = PCURVE('',#3040,#15870); +#15870 = DEFINITIONAL_REPRESENTATION('',(#15871),#15879); +#15871 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15872,#15873,#15874,#15875 + ,#15876,#15877,#15878),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15872 = CARTESIAN_POINT('',(-14.5,-21.65000000002)); +#15873 = CARTESIAN_POINT('',(-11.03589838486,-21.65000000002)); +#15874 = CARTESIAN_POINT('',(-12.76794919243,-24.65000000002)); +#15875 = CARTESIAN_POINT('',(-14.5,-27.65000000002)); +#15876 = CARTESIAN_POINT('',(-16.23205080756,-24.65000000002)); +#15877 = CARTESIAN_POINT('',(-17.96410161513,-21.65000000002)); +#15878 = CARTESIAN_POINT('',(-14.5,-21.65000000002)); +#15879 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15880 = ADVANCED_FACE('',(#15881,#15884),#15838,.T.); +#15881 = FACE_BOUND('',#15882,.T.); +#15882 = EDGE_LOOP('',(#15883)); +#15883 = ORIENTED_EDGE('',*,*,#15823,.F.); +#15884 = FACE_BOUND('',#15885,.T.); +#15885 = EDGE_LOOP('',(#15886)); +#15886 = ORIENTED_EDGE('',*,*,#15887,.F.); +#15887 = EDGE_CURVE('',#15888,#15888,#15890,.T.); +#15888 = VERTEX_POINT('',#15889); +#15889 = CARTESIAN_POINT('',(-73.85000000002,33.600000000004,7.)); +#15890 = SURFACE_CURVE('',#15891,(#15896,#15903),.PCURVE_S1.); +#15891 = CIRCLE('',#15892,1.05); +#15892 = AXIS2_PLACEMENT_3D('',#15893,#15894,#15895); +#15893 = CARTESIAN_POINT('',(-72.80000000002,33.600000000005,7.)); +#15894 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#15895 = DIRECTION('',(1.,-7.174263050427E-13,1.314571968028E-27)); +#15896 = PCURVE('',#15838,#15897); +#15897 = DEFINITIONAL_REPRESENTATION('',(#15898),#15902); +#15898 = CIRCLE('',#15899,1.05); +#15899 = AXIS2_PLACEMENT_2D('',#15900,#15901); +#15900 = CARTESIAN_POINT('',(-14.5,-17.90000000001)); +#15901 = DIRECTION('',(6.792299668617E-28,1.)); +#15902 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15903 = PCURVE('',#15904,#15909); +#15904 = CYLINDRICAL_SURFACE('',#15905,1.05); +#15905 = AXIS2_PLACEMENT_3D('',#15906,#15907,#15908); +#15906 = CARTESIAN_POINT('',(-72.79999999997,-30.30000000003,7.)); +#15907 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#15908 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#15909 = DEFINITIONAL_REPRESENTATION('',(#15910),#15914); +#15910 = LINE('',#15911,#15912); +#15911 = CARTESIAN_POINT('',(12.566370614359,-63.90000000004)); +#15912 = VECTOR('',#15913,1.); +#15913 = DIRECTION('',(-1.,0.)); +#15914 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15915 = ADVANCED_FACE('',(#15916),#15930,.F.); +#15916 = FACE_BOUND('',#15917,.F.); +#15917 = EDGE_LOOP('',(#15918,#15948,#15979,#15980)); +#15918 = ORIENTED_EDGE('',*,*,#15919,.T.); +#15919 = EDGE_CURVE('',#15920,#15922,#15924,.T.); +#15920 = VERTEX_POINT('',#15921); +#15921 = CARTESIAN_POINT('',(-74.80000000002,35.600000000003,36.)); +#15922 = VERTEX_POINT('',#15923); +#15923 = CARTESIAN_POINT('',(-74.80000000002,33.600000000003,36.)); +#15924 = SEAM_CURVE('',#15925,(#15929,#15941),.PCURVE_S1.); +#15925 = LINE('',#15926,#15927); +#15926 = CARTESIAN_POINT('',(-74.80000000002,35.600000000003,36.)); +#15927 = VECTOR('',#15928,1.); +#15928 = DIRECTION('',(7.926992395824E-13,-1.,1.224646799147E-16)); +#15929 = PCURVE('',#15930,#15935); +#15930 = CYLINDRICAL_SURFACE('',#15931,2.); +#15931 = AXIS2_PLACEMENT_3D('',#15932,#15933,#15934); +#15932 = CARTESIAN_POINT('',(-72.80000000002,35.600000000005,36.)); +#15933 = DIRECTION('',(7.926992395824E-13,-1.,1.224646799147E-16)); +#15934 = DIRECTION('',(1.,7.926992395824E-13,-1.632123585706E-28)); +#15935 = DEFINITIONAL_REPRESENTATION('',(#15936),#15940); +#15936 = LINE('',#15937,#15938); +#15937 = CARTESIAN_POINT('',(9.424777960769,1.42108547152E-14)); +#15938 = VECTOR('',#15939,1.); +#15939 = DIRECTION('',(0.,1.)); +#15940 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15941 = PCURVE('',#15930,#15942); +#15942 = DEFINITIONAL_REPRESENTATION('',(#15943),#15947); +#15943 = LINE('',#15944,#15945); +#15944 = CARTESIAN_POINT('',(3.14159265359,1.42108547152E-14)); +#15945 = VECTOR('',#15946,1.); +#15946 = DIRECTION('',(0.,1.)); +#15947 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15948 = ORIENTED_EDGE('',*,*,#15949,.F.); +#15949 = EDGE_CURVE('',#15922,#15922,#15950,.T.); +#15950 = SURFACE_CURVE('',#15951,(#15956,#15963),.PCURVE_S1.); +#15951 = CIRCLE('',#15952,2.); +#15952 = AXIS2_PLACEMENT_3D('',#15953,#15954,#15955); +#15953 = CARTESIAN_POINT('',(-72.80000000002,33.600000000005,36.)); +#15954 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15955 = DIRECTION('',(1.,-7.174263050427E-13,1.314322435141E-27)); +#15956 = PCURVE('',#15930,#15957); +#15957 = DEFINITIONAL_REPRESENTATION('',(#15958),#15962); +#15958 = LINE('',#15959,#15960); +#15959 = CARTESIAN_POINT('',(0.,1.999999999997)); +#15960 = VECTOR('',#15961,1.); +#15961 = DIRECTION('',(1.,0.)); +#15962 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15963 = PCURVE('',#15964,#15969); +#15964 = PLANE('',#15965); +#15965 = AXIS2_PLACEMENT_3D('',#15966,#15967,#15968); +#15966 = CARTESIAN_POINT('',(-54.90000000001,33.600000000019,21.5)); +#15967 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#15968 = DIRECTION('',(6.616465975138E-29,9.778100635379E-16,1.)); +#15969 = DEFINITIONAL_REPRESENTATION('',(#15970),#15978); +#15970 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15971,#15972,#15973,#15974 + ,#15975,#15976,#15977),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15971 = CARTESIAN_POINT('',(14.5,-15.90000000001)); +#15972 = CARTESIAN_POINT('',(17.964101615138,-15.90000000001)); +#15973 = CARTESIAN_POINT('',(16.232050807569,-18.90000000001)); +#15974 = CARTESIAN_POINT('',(14.5,-21.90000000001)); +#15975 = CARTESIAN_POINT('',(12.767949192431,-18.90000000001)); +#15976 = CARTESIAN_POINT('',(11.035898384862,-15.90000000001)); +#15977 = CARTESIAN_POINT('',(14.5,-15.90000000001)); +#15978 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15979 = ORIENTED_EDGE('',*,*,#15919,.F.); +#15980 = ORIENTED_EDGE('',*,*,#15981,.T.); +#15981 = EDGE_CURVE('',#15920,#15920,#15982,.T.); +#15982 = SURFACE_CURVE('',#15983,(#15988,#15995),.PCURVE_S1.); +#15983 = CIRCLE('',#15984,2.); +#15984 = AXIS2_PLACEMENT_3D('',#15985,#15986,#15987); +#15985 = CARTESIAN_POINT('',(-72.80000000002,35.599999999996,36.)); +#15986 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#15987 = DIRECTION('',(1.,-7.174263050427E-13,1.313403596169E-27)); +#15988 = PCURVE('',#15930,#15989); +#15989 = DEFINITIONAL_REPRESENTATION('',(#15990),#15994); +#15990 = LINE('',#15991,#15992); +#15991 = CARTESIAN_POINT('',(0.,5.677236458723E-12)); +#15992 = VECTOR('',#15993,1.); +#15993 = DIRECTION('',(1.,0.)); +#15994 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#15995 = PCURVE('',#3040,#15996); +#15996 = DEFINITIONAL_REPRESENTATION('',(#15997),#16005); +#15997 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#15998,#15999,#16000,#16001 + ,#16002,#16003,#16004),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#15998 = CARTESIAN_POINT('',(14.5,-21.65000000002)); +#15999 = CARTESIAN_POINT('',(17.964101615138,-21.65000000002)); +#16000 = CARTESIAN_POINT('',(16.232050807569,-24.65000000002)); +#16001 = CARTESIAN_POINT('',(14.5,-27.65000000002)); +#16002 = CARTESIAN_POINT('',(12.767949192431,-24.65000000002)); +#16003 = CARTESIAN_POINT('',(11.035898384862,-21.65000000002)); +#16004 = CARTESIAN_POINT('',(14.5,-21.65000000002)); +#16005 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16006 = ADVANCED_FACE('',(#16007,#16010),#15964,.T.); +#16007 = FACE_BOUND('',#16008,.T.); +#16008 = EDGE_LOOP('',(#16009)); +#16009 = ORIENTED_EDGE('',*,*,#15949,.F.); +#16010 = FACE_BOUND('',#16011,.T.); +#16011 = EDGE_LOOP('',(#16012)); +#16012 = ORIENTED_EDGE('',*,*,#16013,.F.); +#16013 = EDGE_CURVE('',#16014,#16014,#16016,.T.); +#16014 = VERTEX_POINT('',#16015); +#16015 = CARTESIAN_POINT('',(-73.85000000002,33.600000000004,36.)); +#16016 = SURFACE_CURVE('',#16017,(#16022,#16029),.PCURVE_S1.); +#16017 = CIRCLE('',#16018,1.05); +#16018 = AXIS2_PLACEMENT_3D('',#16019,#16020,#16021); +#16019 = CARTESIAN_POINT('',(-72.80000000002,33.600000000005,36.)); +#16020 = DIRECTION('',(7.174263050427E-13,1.,-9.778100635379E-16)); +#16021 = DIRECTION('',(1.,-7.174263050427E-13,1.314571968028E-27)); +#16022 = PCURVE('',#15964,#16023); +#16023 = DEFINITIONAL_REPRESENTATION('',(#16024),#16028); +#16024 = CIRCLE('',#16025,1.05); +#16025 = AXIS2_PLACEMENT_2D('',#16026,#16027); +#16026 = CARTESIAN_POINT('',(14.5,-17.90000000001)); +#16027 = DIRECTION('',(6.792299668617E-28,1.)); +#16028 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16029 = PCURVE('',#16030,#16035); +#16030 = CYLINDRICAL_SURFACE('',#16031,1.05); +#16031 = AXIS2_PLACEMENT_3D('',#16032,#16033,#16034); +#16032 = CARTESIAN_POINT('',(-72.79999999997,-30.30000000003,36.)); +#16033 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#16034 = DIRECTION('',(1.,7.934952485434E-13,-1.62822332285E-28)); +#16035 = DEFINITIONAL_REPRESENTATION('',(#16036),#16040); +#16036 = LINE('',#16037,#16038); +#16037 = CARTESIAN_POINT('',(12.566370614359,-63.90000000004)); +#16038 = VECTOR('',#16039,1.); +#16039 = DIRECTION('',(-1.,0.)); +#16040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16041 = ADVANCED_FACE('',(#16042,#16151,#16154,#16157),#3040,.T.); +#16042 = FACE_BOUND('',#16043,.T.); +#16043 = EDGE_LOOP('',(#16044,#16045,#16046,#16069,#16097,#16130)); +#16044 = ORIENTED_EDGE('',*,*,#4525,.F.); +#16045 = ORIENTED_EDGE('',*,*,#3024,.T.); +#16046 = ORIENTED_EDGE('',*,*,#16047,.T.); +#16047 = EDGE_CURVE('',#2997,#16048,#16050,.T.); +#16048 = VERTEX_POINT('',#16049); +#16049 = CARTESIAN_POINT('',(-75.30000000002,35.600000000034,38.5)); +#16050 = SURFACE_CURVE('',#16051,(#16055,#16062),.PCURVE_S1.); +#16051 = LINE('',#16052,#16053); +#16052 = CARTESIAN_POINT('',(-75.30000000002,35.600000000034,13.)); +#16053 = VECTOR('',#16054,1.); +#16054 = DIRECTION('',(-6.128099759578E-28,9.778100635379E-16,1.)); +#16055 = PCURVE('',#3040,#16056); +#16056 = DEFINITIONAL_REPRESENTATION('',(#16057),#16061); +#16057 = LINE('',#16058,#16059); +#16058 = CARTESIAN_POINT('',(-8.5,-26.15000000002)); +#16059 = VECTOR('',#16060,1.); +#16060 = DIRECTION('',(1.,-6.789746357092E-28)); +#16061 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16062 = PCURVE('',#3012,#16063); +#16063 = DEFINITIONAL_REPRESENTATION('',(#16064),#16068); +#16064 = LINE('',#16065,#16066); +#16065 = CARTESIAN_POINT('',(25.5,-65.90000000007)); +#16066 = VECTOR('',#16067,1.); +#16067 = DIRECTION('',(-1.,1.349994788489E-16)); +#16068 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16069 = ORIENTED_EDGE('',*,*,#16070,.T.); +#16070 = EDGE_CURVE('',#16048,#16071,#16073,.T.); +#16071 = VERTEX_POINT('',#16072); +#16072 = CARTESIAN_POINT('',(-34.00685424949,35.600000000004,38.5)); +#16073 = SURFACE_CURVE('',#16074,(#16078,#16085),.PCURVE_S1.); +#16074 = LINE('',#16075,#16076); +#16075 = CARTESIAN_POINT('',(-62.22499999996,35.600000000024,38.5)); +#16076 = VECTOR('',#16077,1.); +#16077 = DIRECTION('',(1.,-7.174263050427E-13,1.018942737707E-15)); +#16078 = PCURVE('',#3040,#16079); +#16079 = DEFINITIONAL_REPRESENTATION('',(#16080),#16084); +#16080 = LINE('',#16081,#16082); +#16081 = CARTESIAN_POINT('',(17.,-13.07499999996)); +#16082 = VECTOR('',#16083,1.); +#16083 = DIRECTION('',(1.018942737706E-15,1.)); +#16084 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16085 = PCURVE('',#16086,#16091); +#16086 = PLANE('',#16087); +#16087 = AXIS2_PLACEMENT_3D('',#16088,#16089,#16090); +#16088 = CARTESIAN_POINT('',(-32.34999999995,-30.3,38.5)); +#16089 = DIRECTION('',(-1.018942737707E-15,1.798273018971E-15,1.)); +#16090 = DIRECTION('',(-1.,-7.938040362974E-13,-1.018942737705E-15)); +#16091 = DEFINITIONAL_REPRESENTATION('',(#16092),#16096); +#16092 = LINE('',#16093,#16094); +#16093 = CARTESIAN_POINT('',(29.874999999964,-65.90000000005)); +#16094 = VECTOR('',#16095,1.); +#16095 = DIRECTION('',(-1.,1.51123034134E-12)); +#16096 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16097 = ORIENTED_EDGE('',*,*,#16098,.F.); +#16098 = EDGE_CURVE('',#16099,#16071,#16101,.T.); +#16099 = VERTEX_POINT('',#16100); +#16100 = CARTESIAN_POINT('',(-31.17842712475,35.600000000002, + 37.328427124746)); +#16101 = SURFACE_CURVE('',#16102,(#16107,#16118),.PCURVE_S1.); +#16102 = CIRCLE('',#16103,4.); +#16103 = AXIS2_PLACEMENT_3D('',#16104,#16105,#16106); +#16104 = CARTESIAN_POINT('',(-34.00685424949,35.600000000027,34.5)); +#16105 = DIRECTION('',(-7.174263050427E-13,-1.,9.778100635379E-16)); +#16106 = DIRECTION('',(0.382683432365,-2.736437821784E-13,0.923879532511 + )); +#16107 = PCURVE('',#3040,#16108); +#16108 = DEFINITIONAL_REPRESENTATION('',(#16109),#16117); +#16109 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#16110,#16111,#16112,#16113 + ,#16114,#16115,#16116),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#16110 = CARTESIAN_POINT('',(16.695518130045,16.673879479972)); +#16111 = CARTESIAN_POINT('',(19.34682672233,10.273054318442)); +#16112 = CARTESIAN_POINT('',(12.47789523112,11.177366305017)); +#16113 = CARTESIAN_POINT('',(5.60896373991,12.081678291591)); +#16114 = CARTESIAN_POINT('',(9.826586638835,17.578191466547)); +#16115 = CARTESIAN_POINT('',(14.04420953776,23.074704641502)); +#16116 = CARTESIAN_POINT('',(16.695518130045,16.673879479972)); +#16117 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16118 = PCURVE('',#16119,#16124); +#16119 = CYLINDRICAL_SURFACE('',#16120,4.); +#16120 = AXIS2_PLACEMENT_3D('',#16121,#16122,#16123); +#16121 = CARTESIAN_POINT('',(-34.00685424944,-30.3,34.5)); +#16122 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#16123 = DIRECTION('',(0.382683432365,3.053188729141E-13,0.923879532511) + ); +#16124 = DEFINITIONAL_REPRESENTATION('',(#16125),#16129); +#16125 = LINE('',#16126,#16127); +#16126 = CARTESIAN_POINT('',(-6.28318530718,-65.89999999999)); +#16127 = VECTOR('',#16128,1.); +#16128 = DIRECTION('',(1.,-5.428146656364E-12)); +#16129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16130 = ORIENTED_EDGE('',*,*,#16131,.T.); +#16131 = EDGE_CURVE('',#16099,#4526,#16132,.T.); +#16132 = SURFACE_CURVE('',#16133,(#16137,#16144),.PCURVE_S1.); +#16133 = LINE('',#16134,#16135); +#16134 = CARTESIAN_POINT('',(-32.29999999998,35.600000000003, + 38.449999999976)); +#16135 = VECTOR('',#16136,1.); +#16136 = DIRECTION('',(0.707106781187,-5.079884214239E-13, + -0.707106781187)); +#16137 = PCURVE('',#3040,#16138); +#16138 = DEFINITIONAL_REPRESENTATION('',(#16139),#16143); +#16139 = LINE('',#16140,#16141); +#16140 = CARTESIAN_POINT('',(16.949999999976,16.850000000029)); +#16141 = VECTOR('',#16142,1.); +#16142 = DIRECTION('',(-0.707106781187,0.707106781187)); +#16143 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16144 = PCURVE('',#4609,#16145); +#16145 = DEFINITIONAL_REPRESENTATION('',(#16146),#16150); +#16146 = LINE('',#16147,#16148); +#16147 = CARTESIAN_POINT('',(13.152186130035,-65.9)); +#16148 = VECTOR('',#16149,1.); +#16149 = DIRECTION('',(-1.,1.068505763249E-12)); +#16150 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16151 = FACE_BOUND('',#16152,.T.); +#16152 = EDGE_LOOP('',(#16153)); +#16153 = ORIENTED_EDGE('',*,*,#15981,.T.); +#16154 = FACE_BOUND('',#16155,.T.); +#16155 = EDGE_LOOP('',(#16156)); +#16156 = ORIENTED_EDGE('',*,*,#15855,.T.); +#16157 = FACE_BOUND('',#16158,.T.); +#16158 = EDGE_LOOP('',(#16159)); +#16159 = ORIENTED_EDGE('',*,*,#15729,.T.); +#16160 = ADVANCED_FACE('',(#16161),#16030,.F.); +#16161 = FACE_BOUND('',#16162,.F.); +#16162 = EDGE_LOOP('',(#16163,#16186,#16187,#16188)); +#16163 = ORIENTED_EDGE('',*,*,#16164,.T.); +#16164 = EDGE_CURVE('',#16165,#16014,#16167,.T.); +#16165 = VERTEX_POINT('',#16166); +#16166 = CARTESIAN_POINT('',(-73.85000000002,30.599999999991,36.)); +#16167 = SEAM_CURVE('',#16168,(#16172,#16179),.PCURVE_S1.); +#16168 = LINE('',#16169,#16170); +#16169 = CARTESIAN_POINT('',(-73.84999999997,-30.30000000003,36.)); +#16170 = VECTOR('',#16171,1.); +#16171 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#16172 = PCURVE('',#16030,#16173); +#16173 = DEFINITIONAL_REPRESENTATION('',(#16174),#16178); +#16174 = LINE('',#16175,#16176); +#16175 = CARTESIAN_POINT('',(3.14159265359,-3.552713678801E-14)); +#16176 = VECTOR('',#16177,1.); +#16177 = DIRECTION('',(0.,-1.)); +#16178 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16179 = PCURVE('',#16030,#16180); +#16180 = DEFINITIONAL_REPRESENTATION('',(#16181),#16185); +#16181 = LINE('',#16182,#16183); +#16182 = CARTESIAN_POINT('',(9.424777960769,-3.552713678801E-14)); +#16183 = VECTOR('',#16184,1.); +#16184 = DIRECTION('',(0.,-1.)); +#16185 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16186 = ORIENTED_EDGE('',*,*,#16013,.F.); +#16187 = ORIENTED_EDGE('',*,*,#16164,.F.); +#16188 = ORIENTED_EDGE('',*,*,#16189,.F.); +#16189 = EDGE_CURVE('',#16165,#16165,#16190,.T.); +#16190 = SURFACE_CURVE('',#16191,(#16196,#16203),.PCURVE_S1.); +#16191 = CIRCLE('',#16192,1.05); +#16192 = AXIS2_PLACEMENT_3D('',#16193,#16194,#16195); +#16193 = CARTESIAN_POINT('',(-72.80000000002,30.599999999992,36.)); +#16194 = DIRECTION('',(-1.244603055572E-60,-1.,1.224646799147E-16)); +#16195 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#16196 = PCURVE('',#16030,#16197); +#16197 = DEFINITIONAL_REPRESENTATION('',(#16198),#16202); +#16198 = LINE('',#16199,#16200); +#16199 = CARTESIAN_POINT('',(0.,-60.90000000003)); +#16200 = VECTOR('',#16201,1.); +#16201 = DIRECTION('',(1.,0.)); +#16202 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16203 = PCURVE('',#2984,#16204); +#16204 = DEFINITIONAL_REPRESENTATION('',(#16205),#16213); +#16205 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#16206,#16207,#16208,#16209 + ,#16210,#16211,#16212),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#16206 = CARTESIAN_POINT('',(48.750000000076,31.5)); +#16207 = CARTESIAN_POINT('',(48.750000000076,33.318653347947)); +#16208 = CARTESIAN_POINT('',(50.325000000076,32.409326673974)); +#16209 = CARTESIAN_POINT('',(51.900000000076,31.5)); +#16210 = CARTESIAN_POINT('',(50.325000000076,30.590673326026)); +#16211 = CARTESIAN_POINT('',(48.750000000076,29.681346652053)); +#16212 = CARTESIAN_POINT('',(48.750000000076,31.5)); +#16213 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16214 = ADVANCED_FACE('',(#16215),#15778,.F.); +#16215 = FACE_BOUND('',#16216,.F.); +#16216 = EDGE_LOOP('',(#16217,#16240,#16241,#16242)); +#16217 = ORIENTED_EDGE('',*,*,#16218,.T.); +#16218 = EDGE_CURVE('',#16219,#15762,#16221,.T.); +#16219 = VERTEX_POINT('',#16220); +#16220 = CARTESIAN_POINT('',(-38.05,30.600000000019,7.)); +#16221 = SEAM_CURVE('',#16222,(#16226,#16233),.PCURVE_S1.); +#16222 = LINE('',#16223,#16224); +#16223 = CARTESIAN_POINT('',(-38.04999999995,-30.30000000001,7.)); +#16224 = VECTOR('',#16225,1.); +#16225 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#16226 = PCURVE('',#15778,#16227); +#16227 = DEFINITIONAL_REPRESENTATION('',(#16228),#16232); +#16228 = LINE('',#16229,#16230); +#16229 = CARTESIAN_POINT('',(3.14159265359,-3.552713678801E-14)); +#16230 = VECTOR('',#16231,1.); +#16231 = DIRECTION('',(4.440892098482E-15,-1.)); +#16232 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16233 = PCURVE('',#15778,#16234); +#16234 = DEFINITIONAL_REPRESENTATION('',(#16235),#16239); +#16235 = LINE('',#16236,#16237); +#16236 = CARTESIAN_POINT('',(9.424777960769,-3.552713678801E-14)); +#16237 = VECTOR('',#16238,1.); +#16238 = DIRECTION('',(4.440892098482E-15,-1.)); +#16239 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16240 = ORIENTED_EDGE('',*,*,#15761,.F.); +#16241 = ORIENTED_EDGE('',*,*,#16218,.F.); +#16242 = ORIENTED_EDGE('',*,*,#16243,.F.); +#16243 = EDGE_CURVE('',#16219,#16219,#16244,.T.); +#16244 = SURFACE_CURVE('',#16245,(#16250,#16257),.PCURVE_S1.); +#16245 = CIRCLE('',#16246,1.05); +#16246 = AXIS2_PLACEMENT_3D('',#16247,#16248,#16249); +#16247 = CARTESIAN_POINT('',(-37.,30.60000000002,7.)); +#16248 = DIRECTION('',(1.244603055572E-60,-1.,1.224646799147E-16)); +#16249 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#16250 = PCURVE('',#15778,#16251); +#16251 = DEFINITIONAL_REPRESENTATION('',(#16252),#16256); +#16252 = LINE('',#16253,#16254); +#16253 = CARTESIAN_POINT('',(-1.33226762955E-14,-60.90000000003)); +#16254 = VECTOR('',#16255,1.); +#16255 = DIRECTION('',(1.,0.)); +#16256 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16257 = PCURVE('',#2984,#16258); +#16258 = DEFINITIONAL_REPRESENTATION('',(#16259),#16267); +#16259 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#16260,#16261,#16262,#16263 + ,#16264,#16265,#16266),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#16260 = CARTESIAN_POINT('',(12.950000000055,2.5)); +#16261 = CARTESIAN_POINT('',(12.950000000055,4.318653347947)); +#16262 = CARTESIAN_POINT('',(14.525000000055,3.409326673974)); +#16263 = CARTESIAN_POINT('',(16.100000000055,2.5)); +#16264 = CARTESIAN_POINT('',(14.525000000055,1.590673326026)); +#16265 = CARTESIAN_POINT('',(12.950000000055,0.681346652053)); +#16266 = CARTESIAN_POINT('',(12.950000000055,2.5)); +#16267 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16268 = ADVANCED_FACE('',(#16269),#15904,.F.); +#16269 = FACE_BOUND('',#16270,.F.); +#16270 = EDGE_LOOP('',(#16271,#16294,#16295,#16296)); +#16271 = ORIENTED_EDGE('',*,*,#16272,.T.); +#16272 = EDGE_CURVE('',#16273,#15888,#16275,.T.); +#16273 = VERTEX_POINT('',#16274); +#16274 = CARTESIAN_POINT('',(-73.85000000002,30.599999999991,7.)); +#16275 = SEAM_CURVE('',#16276,(#16280,#16287),.PCURVE_S1.); +#16276 = LINE('',#16277,#16278); +#16277 = CARTESIAN_POINT('',(-73.84999999997,-30.30000000003,7.)); +#16278 = VECTOR('',#16279,1.); +#16279 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#16280 = PCURVE('',#15904,#16281); +#16281 = DEFINITIONAL_REPRESENTATION('',(#16282),#16286); +#16282 = LINE('',#16283,#16284); +#16283 = CARTESIAN_POINT('',(3.14159265359,-3.552713678801E-14)); +#16284 = VECTOR('',#16285,1.); +#16285 = DIRECTION('',(4.440892098482E-15,-1.)); +#16286 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16287 = PCURVE('',#15904,#16288); +#16288 = DEFINITIONAL_REPRESENTATION('',(#16289),#16293); +#16289 = LINE('',#16290,#16291); +#16290 = CARTESIAN_POINT('',(9.424777960769,-3.552713678801E-14)); +#16291 = VECTOR('',#16292,1.); +#16292 = DIRECTION('',(4.440892098482E-15,-1.)); +#16293 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16294 = ORIENTED_EDGE('',*,*,#15887,.F.); +#16295 = ORIENTED_EDGE('',*,*,#16272,.F.); +#16296 = ORIENTED_EDGE('',*,*,#16297,.F.); +#16297 = EDGE_CURVE('',#16273,#16273,#16298,.T.); +#16298 = SURFACE_CURVE('',#16299,(#16304,#16311),.PCURVE_S1.); +#16299 = CIRCLE('',#16300,1.05); +#16300 = AXIS2_PLACEMENT_3D('',#16301,#16302,#16303); +#16301 = CARTESIAN_POINT('',(-72.80000000002,30.599999999992,7.)); +#16302 = DIRECTION('',(-1.244603055572E-60,-1.,1.224646799147E-16)); +#16303 = DIRECTION('',(1.,-8.039462191265E-45,-6.564719065826E-29)); +#16304 = PCURVE('',#15904,#16305); +#16305 = DEFINITIONAL_REPRESENTATION('',(#16306),#16310); +#16306 = LINE('',#16307,#16308); +#16307 = CARTESIAN_POINT('',(-1.33226762955E-14,-60.90000000003)); +#16308 = VECTOR('',#16309,1.); +#16309 = DIRECTION('',(1.,0.)); +#16310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16311 = PCURVE('',#2984,#16312); +#16312 = DEFINITIONAL_REPRESENTATION('',(#16313),#16321); +#16313 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#16314,#16315,#16316,#16317 + ,#16318,#16319,#16320),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#16314 = CARTESIAN_POINT('',(48.750000000076,2.5)); +#16315 = CARTESIAN_POINT('',(48.750000000076,4.318653347947)); +#16316 = CARTESIAN_POINT('',(50.325000000076,3.409326673974)); +#16317 = CARTESIAN_POINT('',(51.900000000076,2.5)); +#16318 = CARTESIAN_POINT('',(50.325000000076,1.590673326026)); +#16319 = CARTESIAN_POINT('',(48.750000000076,0.681346652053)); +#16320 = CARTESIAN_POINT('',(48.750000000076,2.5)); +#16321 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16322 = ADVANCED_FACE('',(#16323),#3012,.T.); +#16323 = FACE_BOUND('',#16324,.T.); +#16324 = EDGE_LOOP('',(#16325,#16348,#16369,#16370)); +#16325 = ORIENTED_EDGE('',*,*,#16326,.T.); +#16326 = EDGE_CURVE('',#2969,#16327,#16329,.T.); +#16327 = VERTEX_POINT('',#16328); +#16328 = CARTESIAN_POINT('',(-75.30000000002,30.600000000031,38.5)); +#16329 = SURFACE_CURVE('',#16330,(#16334,#16341),.PCURVE_S1.); +#16330 = LINE('',#16331,#16332); +#16331 = CARTESIAN_POINT('',(-75.30000000002,30.600000000031,21.5)); +#16332 = VECTOR('',#16333,1.); +#16333 = DIRECTION('',(6.585885338563E-29,1.224646799147E-16,1.)); +#16334 = PCURVE('',#3012,#16335); +#16335 = DEFINITIONAL_REPRESENTATION('',(#16336),#16340); +#16336 = LINE('',#16337,#16338); +#16337 = CARTESIAN_POINT('',(17.,-60.90000000007)); +#16338 = VECTOR('',#16339,1.); +#16339 = DIRECTION('',(-1.,9.903448624721E-16)); +#16340 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16341 = PCURVE('',#2984,#16342); +#16342 = DEFINITIONAL_REPRESENTATION('',(#16343),#16347); +#16343 = LINE('',#16344,#16345); +#16344 = CARTESIAN_POINT('',(52.300000000076,17.)); +#16345 = VECTOR('',#16346,1.); +#16346 = DIRECTION('',(3.058063657533E-31,1.)); +#16347 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16348 = ORIENTED_EDGE('',*,*,#16349,.F.); +#16349 = EDGE_CURVE('',#16048,#16327,#16350,.T.); +#16350 = SURFACE_CURVE('',#16351,(#16355,#16362),.PCURVE_S1.); +#16351 = LINE('',#16352,#16353); +#16352 = CARTESIAN_POINT('',(-75.29999999997,-30.30000000004,38.5)); +#16353 = VECTOR('',#16354,1.); +#16354 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#16355 = PCURVE('',#3012,#16356); +#16356 = DEFINITIONAL_REPRESENTATION('',(#16357),#16361); +#16357 = LINE('',#16358,#16359); +#16358 = CARTESIAN_POINT('',(0.,0.)); +#16359 = VECTOR('',#16360,1.); +#16360 = DIRECTION('',(-6.854634765848E-16,1.)); +#16361 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16362 = PCURVE('',#16086,#16363); +#16363 = DEFINITIONAL_REPRESENTATION('',(#16364),#16368); +#16364 = LINE('',#16365,#16366); +#16365 = CARTESIAN_POINT('',(42.950000000024,5.062530134941E-15)); +#16366 = VECTOR('',#16367,1.); +#16367 = DIRECTION('',(3.087877539851E-16,1.)); +#16368 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16369 = ORIENTED_EDGE('',*,*,#16047,.F.); +#16370 = ORIENTED_EDGE('',*,*,#2996,.T.); +#16371 = ADVANCED_FACE('',(#16372),#4609,.T.); +#16372 = FACE_BOUND('',#16373,.T.); +#16373 = EDGE_LOOP('',(#16374,#16375,#16376,#16377,#16378,#16401)); +#16374 = ORIENTED_EDGE('',*,*,#5605,.F.); +#16375 = ORIENTED_EDGE('',*,*,#4625,.F.); +#16376 = ORIENTED_EDGE('',*,*,#4572,.F.); +#16377 = ORIENTED_EDGE('',*,*,#16131,.F.); +#16378 = ORIENTED_EDGE('',*,*,#16379,.F.); +#16379 = EDGE_CURVE('',#16380,#16099,#16382,.T.); +#16380 = VERTEX_POINT('',#16381); +#16381 = CARTESIAN_POINT('',(-31.17842712474,30.600000000031, + 37.328427124746)); +#16382 = SURFACE_CURVE('',#16383,(#16387,#16394),.PCURVE_S1.); +#16383 = LINE('',#16384,#16385); +#16384 = CARTESIAN_POINT('',(-31.17842712469,-30.3,37.328427124746)); +#16385 = VECTOR('',#16386,1.); +#16386 = DIRECTION('',(-7.934952485434E-13,1.,-1.798273018972E-15)); +#16387 = PCURVE('',#4609,#16388); +#16388 = DEFINITIONAL_REPRESENTATION('',(#16389),#16393); +#16389 = LINE('',#16390,#16391); +#16390 = CARTESIAN_POINT('',(11.566042558695,-8.80828086E-14)); +#16391 = VECTOR('',#16392,1.); +#16392 = DIRECTION('',(-7.030417873387E-16,-1.)); +#16393 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16394 = PCURVE('',#16119,#16395); +#16395 = DEFINITIONAL_REPRESENTATION('',(#16396),#16400); +#16396 = LINE('',#16397,#16398); +#16397 = CARTESIAN_POINT('',(-0.392699081699,-5.684341886081E-14)); +#16398 = VECTOR('',#16399,1.); +#16399 = DIRECTION('',(-1.776356839411E-16,-1.)); +#16400 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16401 = ORIENTED_EDGE('',*,*,#16402,.T.); +#16402 = EDGE_CURVE('',#16380,#5606,#16403,.T.); +#16403 = SURFACE_CURVE('',#16404,(#16408,#16415),.PCURVE_S1.); +#16404 = LINE('',#16405,#16406); +#16405 = CARTESIAN_POINT('',(-16.83749999997,30.600000000031, + 22.987499999974)); +#16406 = VECTOR('',#16407,1.); +#16407 = DIRECTION('',(0.707106781187,-8.659560562355E-17, + -0.707106781187)); +#16408 = PCURVE('',#4609,#16409); +#16409 = DEFINITIONAL_REPRESENTATION('',(#16410),#16414); +#16410 = LINE('',#16411,#16412); +#16411 = CARTESIAN_POINT('',(-8.71509107816,-60.90000000002)); +#16412 = VECTOR('',#16413,1.); +#16413 = DIRECTION('',(-1.,5.606039374312E-13)); +#16414 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16415 = PCURVE('',#2984,#16416); +#16416 = DEFINITIONAL_REPRESENTATION('',(#16417),#16421); +#16417 = LINE('',#16418,#16419); +#16418 = CARTESIAN_POINT('',(-6.162499999973,18.487499999974)); +#16419 = VECTOR('',#16420,1.); +#16420 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#16421 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16422 = ADVANCED_FACE('',(#16423),#16119,.T.); +#16423 = FACE_BOUND('',#16424,.T.); +#16424 = EDGE_LOOP('',(#16425,#16449,#16450,#16451)); +#16425 = ORIENTED_EDGE('',*,*,#16426,.T.); +#16426 = EDGE_CURVE('',#16427,#16380,#16429,.T.); +#16427 = VERTEX_POINT('',#16428); +#16428 = CARTESIAN_POINT('',(-34.00685424949,30.600000000031,38.5)); +#16429 = SURFACE_CURVE('',#16430,(#16435,#16442),.PCURVE_S1.); +#16430 = CIRCLE('',#16431,4.); +#16431 = AXIS2_PLACEMENT_3D('',#16432,#16433,#16434); +#16432 = CARTESIAN_POINT('',(-34.00685424949,30.600000000023,34.5)); +#16433 = DIRECTION('',(-2.607556941129E-34,1.,-1.224646799147E-16)); +#16434 = DIRECTION('',(0.382683432365,1.131426112288E-16,0.923879532511) + ); +#16435 = PCURVE('',#16119,#16436); +#16436 = DEFINITIONAL_REPRESENTATION('',(#16437),#16441); +#16437 = LINE('',#16438,#16439); +#16438 = CARTESIAN_POINT('',(6.28318530718,-60.90000000004)); +#16439 = VECTOR('',#16440,1.); +#16440 = DIRECTION('',(-1.,2.849776994591E-12)); +#16441 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16442 = PCURVE('',#2984,#16443); +#16443 = DEFINITIONAL_REPRESENTATION('',(#16444),#16448); +#16444 = CIRCLE('',#16445,4.); +#16445 = AXIS2_PLACEMENT_2D('',#16446,#16447); +#16446 = CARTESIAN_POINT('',(11.006854249544,30.)); +#16447 = DIRECTION('',(-0.382683432365,0.923879532511)); +#16448 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16449 = ORIENTED_EDGE('',*,*,#16379,.T.); +#16450 = ORIENTED_EDGE('',*,*,#16098,.T.); +#16451 = ORIENTED_EDGE('',*,*,#16452,.T.); +#16452 = EDGE_CURVE('',#16071,#16427,#16453,.T.); +#16453 = SURFACE_CURVE('',#16454,(#16458,#16465),.PCURVE_S1.); +#16454 = LINE('',#16455,#16456); +#16455 = CARTESIAN_POINT('',(-34.00685424944,-30.3,38.5)); +#16456 = VECTOR('',#16457,1.); +#16457 = DIRECTION('',(7.934952485434E-13,-1.,1.798273018972E-15)); +#16458 = PCURVE('',#16119,#16459); +#16459 = DEFINITIONAL_REPRESENTATION('',(#16460),#16464); +#16460 = LINE('',#16461,#16462); +#16461 = CARTESIAN_POINT('',(0.392699081699,1.42108547152E-14)); +#16462 = VECTOR('',#16463,1.); +#16463 = DIRECTION('',(1.554312234484E-16,1.)); +#16464 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16465 = PCURVE('',#16086,#16466); +#16466 = DEFINITIONAL_REPRESENTATION('',(#16467),#16471); +#16467 = LINE('',#16468,#16469); +#16468 = CARTESIAN_POINT('',(1.656854249492,-1.492438436264E-14)); +#16469 = VECTOR('',#16470,1.); +#16470 = DIRECTION('',(3.087877539851E-16,1.)); +#16471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16472 = ADVANCED_FACE('',(#16473),#16086,.T.); +#16473 = FACE_BOUND('',#16474,.T.); +#16474 = EDGE_LOOP('',(#16475,#16496,#16497,#16498)); +#16475 = ORIENTED_EDGE('',*,*,#16476,.T.); +#16476 = EDGE_CURVE('',#16327,#16427,#16477,.T.); +#16477 = SURFACE_CURVE('',#16478,(#16482,#16489),.PCURVE_S1.); +#16478 = LINE('',#16479,#16480); +#16479 = CARTESIAN_POINT('',(-27.67499999995,30.600000000031,38.5)); +#16480 = VECTOR('',#16481,1.); +#16481 = DIRECTION('',(1.,1.247844962247E-31,1.018942737707E-15)); +#16482 = PCURVE('',#16086,#16483); +#16483 = DEFINITIONAL_REPRESENTATION('',(#16484),#16488); +#16484 = LINE('',#16485,#16486); +#16485 = CARTESIAN_POINT('',(-4.67500000005,-60.90000000003)); +#16486 = VECTOR('',#16487,1.); +#16487 = DIRECTION('',(-1.,7.938040362974E-13)); +#16488 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16489 = PCURVE('',#2984,#16490); +#16490 = DEFINITIONAL_REPRESENTATION('',(#16491),#16495); +#16491 = LINE('',#16492,#16493); +#16492 = CARTESIAN_POINT('',(4.675000000002,34.)); +#16493 = VECTOR('',#16494,1.); +#16494 = DIRECTION('',(-1.,1.018942737707E-15)); +#16495 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16496 = ORIENTED_EDGE('',*,*,#16452,.F.); +#16497 = ORIENTED_EDGE('',*,*,#16070,.F.); +#16498 = ORIENTED_EDGE('',*,*,#16349,.T.); +#16499 = ADVANCED_FACE('',(#16500,#16508,#16511,#16514),#2984,.F.); +#16500 = FACE_BOUND('',#16501,.T.); +#16501 = EDGE_LOOP('',(#16502,#16503,#16504,#16505,#16506,#16507)); +#16502 = ORIENTED_EDGE('',*,*,#5655,.F.); +#16503 = ORIENTED_EDGE('',*,*,#16402,.F.); +#16504 = ORIENTED_EDGE('',*,*,#16426,.F.); +#16505 = ORIENTED_EDGE('',*,*,#16476,.F.); +#16506 = ORIENTED_EDGE('',*,*,#16326,.F.); +#16507 = ORIENTED_EDGE('',*,*,#2968,.F.); +#16508 = FACE_BOUND('',#16509,.T.); +#16509 = EDGE_LOOP('',(#16510)); +#16510 = ORIENTED_EDGE('',*,*,#16297,.F.); +#16511 = FACE_BOUND('',#16512,.T.); +#16512 = EDGE_LOOP('',(#16513)); +#16513 = ORIENTED_EDGE('',*,*,#16243,.F.); +#16514 = FACE_BOUND('',#16515,.T.); +#16515 = EDGE_LOOP('',(#16516)); +#16516 = ORIENTED_EDGE('',*,*,#16189,.F.); +#16517 = ADVANCED_FACE('',(#16518,#16632,#16638,#16641,#16644,#16647), + #3814,.T.); +#16518 = FACE_BOUND('',#16519,.T.); +#16519 = EDGE_LOOP('',(#16520,#16521,#16542,#16543,#16564,#16565,#16586, + #16587,#16608,#16609,#16630,#16631)); +#16520 = ORIENTED_EDGE('',*,*,#12601,.F.); +#16521 = ORIENTED_EDGE('',*,*,#16522,.F.); +#16522 = EDGE_CURVE('',#12989,#12579,#16523,.T.); +#16523 = SURFACE_CURVE('',#16524,(#16528,#16535),.PCURVE_S1.); +#16524 = LINE('',#16525,#16526); +#16525 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003, + 11.324999999994)); +#16526 = VECTOR('',#16527,1.); +#16527 = DIRECTION('',(5.511448795321E-29,1.833155447161E-15,1.)); +#16528 = PCURVE('',#3814,#16529); +#16529 = DEFINITIONAL_REPRESENTATION('',(#16530),#16534); +#16530 = LINE('',#16531,#16532); +#16531 = CARTESIAN_POINT('',(-6.824999999993,-24.00000000003)); +#16532 = VECTOR('',#16533,1.); +#16533 = DIRECTION('',(-1.,1.710690767246E-15)); +#16534 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16535 = PCURVE('',#3842,#16536); +#16536 = DEFINITIONAL_REPRESENTATION('',(#16537),#16541); +#16537 = LINE('',#16538,#16539); +#16538 = CARTESIAN_POINT('',(6.824999999993,-2.799999999844)); +#16539 = VECTOR('',#16540,1.); +#16540 = DIRECTION('',(-1.,-1.238344728014E-27)); +#16541 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16542 = ORIENTED_EDGE('',*,*,#13085,.F.); +#16543 = ORIENTED_EDGE('',*,*,#16544,.F.); +#16544 = EDGE_CURVE('',#12889,#13063,#16545,.T.); +#16545 = SURFACE_CURVE('',#16546,(#16550,#16557),.PCURVE_S1.); +#16546 = LINE('',#16547,#16548); +#16547 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003, + 11.324999999994)); +#16548 = VECTOR('',#16549,1.); +#16549 = DIRECTION('',(5.511448795321E-29,1.833155447161E-15,1.)); +#16550 = PCURVE('',#3814,#16551); +#16551 = DEFINITIONAL_REPRESENTATION('',(#16552),#16556); +#16552 = LINE('',#16553,#16554); +#16553 = CARTESIAN_POINT('',(-6.824999999993,-24.00000000003)); +#16554 = VECTOR('',#16555,1.); +#16555 = DIRECTION('',(-1.,1.710690767246E-15)); +#16556 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16557 = PCURVE('',#3842,#16558); +#16558 = DEFINITIONAL_REPRESENTATION('',(#16559),#16563); +#16559 = LINE('',#16560,#16561); +#16560 = CARTESIAN_POINT('',(6.824999999993,-2.799999999844)); +#16561 = VECTOR('',#16562,1.); +#16562 = DIRECTION('',(-1.,-1.238344728014E-27)); +#16563 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16564 = ORIENTED_EDGE('',*,*,#12962,.F.); +#16565 = ORIENTED_EDGE('',*,*,#16566,.F.); +#16566 = EDGE_CURVE('',#12789,#12940,#16567,.T.); +#16567 = SURFACE_CURVE('',#16568,(#16572,#16579),.PCURVE_S1.); +#16568 = LINE('',#16569,#16570); +#16569 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003, + 11.324999999994)); +#16570 = VECTOR('',#16571,1.); +#16571 = DIRECTION('',(5.511448795321E-29,1.833155447161E-15,1.)); +#16572 = PCURVE('',#3814,#16573); +#16573 = DEFINITIONAL_REPRESENTATION('',(#16574),#16578); +#16574 = LINE('',#16575,#16576); +#16575 = CARTESIAN_POINT('',(-6.824999999993,-24.00000000003)); +#16576 = VECTOR('',#16577,1.); +#16577 = DIRECTION('',(-1.,1.710690767246E-15)); +#16578 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16579 = PCURVE('',#3842,#16580); +#16580 = DEFINITIONAL_REPRESENTATION('',(#16581),#16585); +#16581 = LINE('',#16582,#16583); +#16582 = CARTESIAN_POINT('',(6.824999999993,-2.799999999844)); +#16583 = VECTOR('',#16584,1.); +#16584 = DIRECTION('',(-1.,-1.238344728014E-27)); +#16585 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16586 = ORIENTED_EDGE('',*,*,#12862,.F.); +#16587 = ORIENTED_EDGE('',*,*,#16588,.F.); +#16588 = EDGE_CURVE('',#12689,#12840,#16589,.T.); +#16589 = SURFACE_CURVE('',#16590,(#16594,#16601),.PCURVE_S1.); +#16590 = LINE('',#16591,#16592); +#16591 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003, + 11.324999999994)); +#16592 = VECTOR('',#16593,1.); +#16593 = DIRECTION('',(5.511448795321E-29,1.833155447161E-15,1.)); +#16594 = PCURVE('',#3814,#16595); +#16595 = DEFINITIONAL_REPRESENTATION('',(#16596),#16600); +#16596 = LINE('',#16597,#16598); +#16597 = CARTESIAN_POINT('',(-6.824999999993,-24.00000000003)); +#16598 = VECTOR('',#16599,1.); +#16599 = DIRECTION('',(-1.,1.710690767246E-15)); +#16600 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16601 = PCURVE('',#3842,#16602); +#16602 = DEFINITIONAL_REPRESENTATION('',(#16603),#16607); +#16603 = LINE('',#16604,#16605); +#16604 = CARTESIAN_POINT('',(6.824999999993,-2.799999999844)); +#16605 = VECTOR('',#16606,1.); +#16606 = DIRECTION('',(-1.,-1.238344728014E-27)); +#16607 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16608 = ORIENTED_EDGE('',*,*,#12762,.F.); +#16609 = ORIENTED_EDGE('',*,*,#16610,.F.); +#16610 = EDGE_CURVE('',#3799,#12740,#16611,.T.); +#16611 = SURFACE_CURVE('',#16612,(#16616,#16623),.PCURVE_S1.); +#16612 = LINE('',#16613,#16614); +#16613 = CARTESIAN_POINT('',(-25.49999999994,-62.60000000003, + 11.324999999994)); +#16614 = VECTOR('',#16615,1.); +#16615 = DIRECTION('',(5.511448795321E-29,1.833155447161E-15,1.)); +#16616 = PCURVE('',#3814,#16617); +#16617 = DEFINITIONAL_REPRESENTATION('',(#16618),#16622); +#16618 = LINE('',#16619,#16620); +#16619 = CARTESIAN_POINT('',(-6.824999999993,-24.00000000003)); +#16620 = VECTOR('',#16621,1.); +#16621 = DIRECTION('',(-1.,1.710690767246E-15)); +#16622 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16623 = PCURVE('',#3842,#16624); +#16624 = DEFINITIONAL_REPRESENTATION('',(#16625),#16629); +#16625 = LINE('',#16626,#16627); +#16626 = CARTESIAN_POINT('',(6.824999999993,-2.799999999844)); +#16627 = VECTOR('',#16628,1.); +#16628 = DIRECTION('',(-1.,-1.238344728014E-27)); +#16629 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16630 = ORIENTED_EDGE('',*,*,#3798,.T.); +#16631 = ORIENTED_EDGE('',*,*,#5555,.F.); +#16632 = FACE_BOUND('',#16633,.T.); +#16633 = EDGE_LOOP('',(#16634,#16635,#16636,#16637)); +#16634 = ORIENTED_EDGE('',*,*,#14609,.T.); +#16635 = ORIENTED_EDGE('',*,*,#14866,.T.); +#16636 = ORIENTED_EDGE('',*,*,#14795,.T.); +#16637 = ORIENTED_EDGE('',*,*,#14719,.T.); +#16638 = FACE_BOUND('',#16639,.T.); +#16639 = EDGE_LOOP('',(#16640)); +#16640 = ORIENTED_EDGE('',*,*,#15229,.T.); +#16641 = FACE_BOUND('',#16642,.T.); +#16642 = EDGE_LOOP('',(#16643)); +#16643 = ORIENTED_EDGE('',*,*,#15147,.T.); +#16644 = FACE_BOUND('',#16645,.T.); +#16645 = EDGE_LOOP('',(#16646)); +#16646 = ORIENTED_EDGE('',*,*,#15065,.T.); +#16647 = FACE_BOUND('',#16648,.T.); +#16648 = EDGE_LOOP('',(#16649)); +#16649 = ORIENTED_EDGE('',*,*,#14983,.T.); +#16650 = ADVANCED_FACE('',(#16651),#2870,.F.); +#16651 = FACE_BOUND('',#16652,.T.); +#16652 = EDGE_LOOP('',(#16653,#16654,#16655,#16656)); +#16653 = ORIENTED_EDGE('',*,*,#5293,.F.); +#16654 = ORIENTED_EDGE('',*,*,#2854,.F.); +#16655 = ORIENTED_EDGE('',*,*,#11140,.F.); +#16656 = ORIENTED_EDGE('',*,*,#12626,.F.); +#16657 = ADVANCED_FACE('',(#16658,#16664),#4150,.F.); +#16658 = FACE_BOUND('',#16659,.T.); +#16659 = EDGE_LOOP('',(#16660,#16661,#16662,#16663)); +#16660 = ORIENTED_EDGE('',*,*,#4478,.T.); +#16661 = ORIENTED_EDGE('',*,*,#4134,.F.); +#16662 = ORIENTED_EDGE('',*,*,#13850,.T.); +#16663 = ORIENTED_EDGE('',*,*,#12325,.F.); +#16664 = FACE_BOUND('',#16665,.T.); +#16665 = EDGE_LOOP('',(#16666)); +#16666 = ORIENTED_EDGE('',*,*,#10833,.T.); +#16667 = ADVANCED_FACE('',(#16668),#3162,.T.); +#16668 = FACE_BOUND('',#16669,.T.); +#16669 = EDGE_LOOP('',(#16670,#16671,#16672,#16673)); +#16670 = ORIENTED_EDGE('',*,*,#4848,.F.); +#16671 = ORIENTED_EDGE('',*,*,#6294,.T.); +#16672 = ORIENTED_EDGE('',*,*,#8519,.F.); +#16673 = ORIENTED_EDGE('',*,*,#3146,.F.); +#16674 = ADVANCED_FACE('',(#16675),#9957,.T.); +#16675 = FACE_BOUND('',#16676,.T.); +#16676 = EDGE_LOOP('',(#16677,#16698,#16699,#16720)); +#16677 = ORIENTED_EDGE('',*,*,#16678,.F.); +#16678 = EDGE_CURVE('',#9886,#12249,#16679,.T.); +#16679 = SURFACE_CURVE('',#16680,(#16684,#16691),.PCURVE_S1.); +#16680 = LINE('',#16681,#16682); +#16681 = CARTESIAN_POINT('',(19.449999999975,64.599999999996,31.5)); +#16682 = VECTOR('',#16683,1.); +#16683 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16684 = PCURVE('',#9957,#16685); +#16685 = DEFINITIONAL_REPRESENTATION('',(#16686),#16690); +#16686 = LINE('',#16687,#16688); +#16687 = CARTESIAN_POINT('',(45.449999999979,9.196979221536E-14)); +#16688 = VECTOR('',#16689,1.); +#16689 = DIRECTION('',(2.28663820792E-16,1.)); +#16690 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16691 = PCURVE('',#9903,#16692); +#16692 = DEFINITIONAL_REPRESENTATION('',(#16693),#16697); +#16693 = LINE('',#16694,#16695); +#16694 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16695 = VECTOR('',#16696,1.); +#16696 = DIRECTION('',(-1.397496474763E-15,1.)); +#16697 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16698 = ORIENTED_EDGE('',*,*,#9943,.F.); +#16699 = ORIENTED_EDGE('',*,*,#16700,.T.); +#16700 = EDGE_CURVE('',#9916,#12251,#16701,.T.); +#16701 = SURFACE_CURVE('',#16702,(#16706,#16713),.PCURVE_S1.); +#16702 = LINE('',#16703,#16704); +#16703 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,31.5)); +#16704 = VECTOR('',#16705,1.); +#16705 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16706 = PCURVE('',#9957,#16707); +#16707 = DEFINITIONAL_REPRESENTATION('',(#16708),#16712); +#16708 = LINE('',#16709,#16710); +#16709 = CARTESIAN_POINT('',(48.000000000027,3.234991317303E-15)); +#16710 = VECTOR('',#16711,1.); +#16711 = DIRECTION('',(2.28663820792E-16,1.)); +#16712 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16713 = PCURVE('',#9931,#16714); +#16714 = DEFINITIONAL_REPRESENTATION('',(#16715),#16719); +#16715 = LINE('',#16716,#16717); +#16716 = CARTESIAN_POINT('',(0.,0.)); +#16717 = VECTOR('',#16718,1.); +#16718 = DIRECTION('',(1.747694647186E-15,1.)); +#16719 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16720 = ORIENTED_EDGE('',*,*,#12248,.F.); +#16721 = ADVANCED_FACE('',(#16722),#8621,.T.); +#16722 = FACE_BOUND('',#16723,.T.); +#16723 = EDGE_LOOP('',(#16724,#16745,#16746,#16767)); +#16724 = ORIENTED_EDGE('',*,*,#16725,.F.); +#16725 = EDGE_CURVE('',#8606,#11240,#16726,.T.); +#16726 = SURFACE_CURVE('',#16727,(#16731,#16738),.PCURVE_S1.); +#16727 = LINE('',#16728,#16729); +#16728 = CARTESIAN_POINT('',(13.449999999975,64.599999999996,31.5)); +#16729 = VECTOR('',#16730,1.); +#16730 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16731 = PCURVE('',#8621,#16732); +#16732 = DEFINITIONAL_REPRESENTATION('',(#16733),#16737); +#16733 = LINE('',#16734,#16735); +#16734 = CARTESIAN_POINT('',(39.449999999979,6.66964225491E-14)); +#16735 = VECTOR('',#16736,1.); +#16736 = DIRECTION('',(2.28663820792E-16,1.)); +#16737 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16738 = PCURVE('',#8649,#16739); +#16739 = DEFINITIONAL_REPRESENTATION('',(#16740),#16744); +#16740 = LINE('',#16741,#16742); +#16741 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16742 = VECTOR('',#16743,1.); +#16743 = DIRECTION('',(-1.397496474763E-15,1.)); +#16744 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16745 = ORIENTED_EDGE('',*,*,#8603,.F.); +#16746 = ORIENTED_EDGE('',*,*,#16747,.F.); +#16747 = EDGE_CURVE('',#11192,#8604,#16748,.T.); +#16748 = SURFACE_CURVE('',#16749,(#16753,#16760),.PCURVE_S1.); +#16749 = LINE('',#16750,#16751); +#16750 = CARTESIAN_POINT('',(16.449999999975,64.599999999996,31.5)); +#16751 = VECTOR('',#16752,1.); +#16752 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16753 = PCURVE('',#8621,#16754); +#16754 = DEFINITIONAL_REPRESENTATION('',(#16755),#16759); +#16755 = LINE('',#16756,#16757); +#16756 = CARTESIAN_POINT('',(42.449999999979,7.933310738223E-14)); +#16757 = VECTOR('',#16758,1.); +#16758 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16759 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16760 = PCURVE('',#8703,#16761); +#16761 = DEFINITIONAL_REPRESENTATION('',(#16762),#16766); +#16762 = LINE('',#16763,#16764); +#16763 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16764 = VECTOR('',#16765,1.); +#16765 = DIRECTION('',(-1.397496474763E-15,-1.)); +#16766 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16767 = ORIENTED_EDGE('',*,*,#11262,.F.); +#16768 = ADVANCED_FACE('',(#16769),#9789,.T.); +#16769 = FACE_BOUND('',#16770,.T.); +#16770 = EDGE_LOOP('',(#16771,#16792,#16793,#16814)); +#16771 = ORIENTED_EDGE('',*,*,#16772,.F.); +#16772 = EDGE_CURVE('',#9774,#12203,#16773,.T.); +#16773 = SURFACE_CURVE('',#16774,(#16778,#16785),.PCURVE_S1.); +#16774 = LINE('',#16775,#16776); +#16775 = CARTESIAN_POINT('',(7.449999999975,64.599999999996,31.5)); +#16776 = VECTOR('',#16777,1.); +#16777 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16778 = PCURVE('',#9789,#16779); +#16779 = DEFINITIONAL_REPRESENTATION('',(#16780),#16784); +#16780 = LINE('',#16781,#16782); +#16781 = CARTESIAN_POINT('',(33.449999999979,4.142305288285E-14)); +#16782 = VECTOR('',#16783,1.); +#16783 = DIRECTION('',(2.28663820792E-16,1.)); +#16784 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16785 = PCURVE('',#9817,#16786); +#16786 = DEFINITIONAL_REPRESENTATION('',(#16787),#16791); +#16787 = LINE('',#16788,#16789); +#16788 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16789 = VECTOR('',#16790,1.); +#16790 = DIRECTION('',(-1.397496474763E-15,1.)); +#16791 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16792 = ORIENTED_EDGE('',*,*,#9771,.F.); +#16793 = ORIENTED_EDGE('',*,*,#16794,.F.); +#16794 = EDGE_CURVE('',#12155,#9772,#16795,.T.); +#16795 = SURFACE_CURVE('',#16796,(#16800,#16807),.PCURVE_S1.); +#16796 = LINE('',#16797,#16798); +#16797 = CARTESIAN_POINT('',(10.449999999975,64.599999999996,31.5)); +#16798 = VECTOR('',#16799,1.); +#16799 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16800 = PCURVE('',#9789,#16801); +#16801 = DEFINITIONAL_REPRESENTATION('',(#16802),#16806); +#16802 = LINE('',#16803,#16804); +#16803 = CARTESIAN_POINT('',(36.449999999979,5.405973771598E-14)); +#16804 = VECTOR('',#16805,1.); +#16805 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16806 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16807 = PCURVE('',#9871,#16808); +#16808 = DEFINITIONAL_REPRESENTATION('',(#16809),#16813); +#16809 = LINE('',#16810,#16811); +#16810 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16811 = VECTOR('',#16812,1.); +#16812 = DIRECTION('',(-1.397496474763E-15,-1.)); +#16813 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16814 = ORIENTED_EDGE('',*,*,#12225,.F.); +#16815 = ADVANCED_FACE('',(#16816),#8735,.T.); +#16816 = FACE_BOUND('',#16817,.T.); +#16817 = EDGE_LOOP('',(#16818,#16839,#16840,#16861)); +#16818 = ORIENTED_EDGE('',*,*,#16819,.F.); +#16819 = EDGE_CURVE('',#8720,#11357,#16820,.T.); +#16820 = SURFACE_CURVE('',#16821,(#16825,#16832),.PCURVE_S1.); +#16821 = LINE('',#16822,#16823); +#16822 = CARTESIAN_POINT('',(1.449999999975,64.599999999996,31.5)); +#16823 = VECTOR('',#16824,1.); +#16824 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16825 = PCURVE('',#8735,#16826); +#16826 = DEFINITIONAL_REPRESENTATION('',(#16827),#16831); +#16827 = LINE('',#16828,#16829); +#16828 = CARTESIAN_POINT('',(27.449999999979,1.15625666223E-13)); +#16829 = VECTOR('',#16830,1.); +#16830 = DIRECTION('',(2.28663820792E-16,1.)); +#16831 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16832 = PCURVE('',#8763,#16833); +#16833 = DEFINITIONAL_REPRESENTATION('',(#16834),#16838); +#16834 = LINE('',#16835,#16836); +#16835 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16836 = VECTOR('',#16837,1.); +#16837 = DIRECTION('',(-1.397496474763E-15,1.)); +#16838 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16839 = ORIENTED_EDGE('',*,*,#8717,.F.); +#16840 = ORIENTED_EDGE('',*,*,#16841,.F.); +#16841 = EDGE_CURVE('',#11286,#8718,#16842,.T.); +#16842 = SURFACE_CURVE('',#16843,(#16847,#16854),.PCURVE_S1.); +#16843 = LINE('',#16844,#16845); +#16844 = CARTESIAN_POINT('',(4.449999999975,64.599999999996,31.5)); +#16845 = VECTOR('',#16846,1.); +#16846 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16847 = PCURVE('',#8735,#16848); +#16848 = DEFINITIONAL_REPRESENTATION('',(#16849),#16853); +#16849 = LINE('',#16850,#16851); +#16850 = CARTESIAN_POINT('',(30.449999999979,2.878636804973E-14)); +#16851 = VECTOR('',#16852,1.); +#16852 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16853 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16854 = PCURVE('',#8845,#16855); +#16855 = DEFINITIONAL_REPRESENTATION('',(#16856),#16860); +#16856 = LINE('',#16857,#16858); +#16857 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16858 = VECTOR('',#16859,1.); +#16859 = DIRECTION('',(-1.397496474763E-15,-1.)); +#16860 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16861 = ORIENTED_EDGE('',*,*,#11379,.F.); +#16862 = ADVANCED_FACE('',(#16863),#9675,.T.); +#16863 = FACE_BOUND('',#16864,.T.); +#16864 = EDGE_LOOP('',(#16865,#16886,#16887,#16908)); +#16865 = ORIENTED_EDGE('',*,*,#16866,.F.); +#16866 = EDGE_CURVE('',#9660,#12109,#16867,.T.); +#16867 = SURFACE_CURVE('',#16868,(#16872,#16879),.PCURVE_S1.); +#16868 = LINE('',#16869,#16870); +#16869 = CARTESIAN_POINT('',(-4.550000000025,64.599999999996,31.5)); +#16870 = VECTOR('',#16871,1.); +#16871 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16872 = PCURVE('',#9675,#16873); +#16873 = DEFINITIONAL_REPRESENTATION('',(#16874),#16878); +#16874 = LINE('',#16875,#16876); +#16875 = CARTESIAN_POINT('',(21.449999999979,9.035229655676E-14)); +#16876 = VECTOR('',#16877,1.); +#16877 = DIRECTION('',(2.28663820792E-16,1.)); +#16878 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16879 = PCURVE('',#9703,#16880); +#16880 = DEFINITIONAL_REPRESENTATION('',(#16881),#16885); +#16881 = LINE('',#16882,#16883); +#16882 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16883 = VECTOR('',#16884,1.); +#16884 = DIRECTION('',(-1.397496474763E-15,1.)); +#16885 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16886 = ORIENTED_EDGE('',*,*,#9657,.F.); +#16887 = ORIENTED_EDGE('',*,*,#16888,.F.); +#16888 = EDGE_CURVE('',#12061,#9658,#16889,.T.); +#16889 = SURFACE_CURVE('',#16890,(#16894,#16901),.PCURVE_S1.); +#16890 = LINE('',#16891,#16892); +#16891 = CARTESIAN_POINT('',(-1.550000000025,64.599999999996,31.5)); +#16892 = VECTOR('',#16893,1.); +#16893 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16894 = PCURVE('',#9675,#16895); +#16895 = DEFINITIONAL_REPRESENTATION('',(#16896),#16900); +#16896 = LINE('',#16897,#16898); +#16897 = CARTESIAN_POINT('',(24.449999999979,3.512998383474E-15)); +#16898 = VECTOR('',#16899,1.); +#16899 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16900 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16901 = PCURVE('',#9757,#16902); +#16902 = DEFINITIONAL_REPRESENTATION('',(#16903),#16907); +#16903 = LINE('',#16904,#16905); +#16904 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16905 = VECTOR('',#16906,1.); +#16906 = DIRECTION('',(-1.397496474763E-15,-1.)); +#16907 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16908 = ORIENTED_EDGE('',*,*,#12131,.F.); +#16909 = ADVANCED_FACE('',(#16910),#8877,.T.); +#16910 = FACE_BOUND('',#16911,.T.); +#16911 = EDGE_LOOP('',(#16912,#16933,#16934,#16955)); +#16912 = ORIENTED_EDGE('',*,*,#16913,.F.); +#16913 = EDGE_CURVE('',#8862,#12015,#16914,.T.); +#16914 = SURFACE_CURVE('',#16915,(#16919,#16926),.PCURVE_S1.); +#16915 = LINE('',#16916,#16917); +#16916 = CARTESIAN_POINT('',(-10.55000000002,64.599999999996,31.5)); +#16917 = VECTOR('',#16918,1.); +#16918 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16919 = PCURVE('',#8877,#16920); +#16920 = DEFINITIONAL_REPRESENTATION('',(#16921),#16925); +#16921 = LINE('',#16922,#16923); +#16922 = CARTESIAN_POINT('',(15.449999999979,6.507892689051E-14)); +#16923 = VECTOR('',#16924,1.); +#16924 = DIRECTION('',(2.28663820792E-16,1.)); +#16925 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16926 = PCURVE('',#8905,#16927); +#16927 = DEFINITIONAL_REPRESENTATION('',(#16928),#16932); +#16928 = LINE('',#16929,#16930); +#16929 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16930 = VECTOR('',#16931,1.); +#16931 = DIRECTION('',(-1.397496474763E-15,1.)); +#16932 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16933 = ORIENTED_EDGE('',*,*,#8859,.F.); +#16934 = ORIENTED_EDGE('',*,*,#16935,.F.); +#16935 = EDGE_CURVE('',#11967,#8860,#16936,.T.); +#16936 = SURFACE_CURVE('',#16937,(#16941,#16948),.PCURVE_S1.); +#16937 = LINE('',#16938,#16939); +#16938 = CARTESIAN_POINT('',(-7.550000000025,64.599999999996,31.5)); +#16939 = VECTOR('',#16940,1.); +#16940 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16941 = PCURVE('',#8877,#16942); +#16942 = DEFINITIONAL_REPRESENTATION('',(#16943),#16947); +#16943 = LINE('',#16944,#16945); +#16944 = CARTESIAN_POINT('',(18.449999999979,7.771561172364E-14)); +#16945 = VECTOR('',#16946,1.); +#16946 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16947 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16948 = PCURVE('',#8959,#16949); +#16949 = DEFINITIONAL_REPRESENTATION('',(#16950),#16954); +#16950 = LINE('',#16951,#16952); +#16951 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16952 = VECTOR('',#16953,1.); +#16953 = DIRECTION('',(-1.397496474763E-15,-1.)); +#16954 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16955 = ORIENTED_EDGE('',*,*,#12037,.F.); +#16956 = ADVANCED_FACE('',(#16957),#9561,.T.); +#16957 = FACE_BOUND('',#16958,.T.); +#16958 = EDGE_LOOP('',(#16959,#16980,#16981,#17002)); +#16959 = ORIENTED_EDGE('',*,*,#16960,.F.); +#16960 = EDGE_CURVE('',#9546,#11451,#16961,.T.); +#16961 = SURFACE_CURVE('',#16962,(#16966,#16973),.PCURVE_S1.); +#16962 = LINE('',#16963,#16964); +#16963 = CARTESIAN_POINT('',(-16.55000000002,64.599999999996,31.5)); +#16964 = VECTOR('',#16965,1.); +#16965 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#16966 = PCURVE('',#9561,#16967); +#16967 = DEFINITIONAL_REPRESENTATION('',(#16968),#16972); +#16968 = LINE('',#16969,#16970); +#16969 = CARTESIAN_POINT('',(9.449999999979,3.980555722426E-14)); +#16970 = VECTOR('',#16971,1.); +#16971 = DIRECTION('',(2.28663820792E-16,1.)); +#16972 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16973 = PCURVE('',#9589,#16974); +#16974 = DEFINITIONAL_REPRESENTATION('',(#16975),#16979); +#16975 = LINE('',#16976,#16977); +#16976 = CARTESIAN_POINT('',(35.355339059344,2.6713404526E-14)); +#16977 = VECTOR('',#16978,1.); +#16978 = DIRECTION('',(-1.397496474763E-15,1.)); +#16979 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16980 = ORIENTED_EDGE('',*,*,#9543,.F.); +#16981 = ORIENTED_EDGE('',*,*,#16982,.F.); +#16982 = EDGE_CURVE('',#11403,#9544,#16983,.T.); +#16983 = SURFACE_CURVE('',#16984,(#16988,#16995),.PCURVE_S1.); +#16984 = LINE('',#16985,#16986); +#16985 = CARTESIAN_POINT('',(-13.55000000002,64.599999999996,31.5)); +#16986 = VECTOR('',#16987,1.); +#16987 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#16988 = PCURVE('',#9561,#16989); +#16989 = DEFINITIONAL_REPRESENTATION('',(#16990),#16994); +#16990 = LINE('',#16991,#16992); +#16991 = CARTESIAN_POINT('',(12.449999999979,5.244224205738E-14)); +#16992 = VECTOR('',#16993,1.); +#16993 = DIRECTION('',(-2.28663820792E-16,-1.)); +#16994 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#16995 = PCURVE('',#9643,#16996); +#16996 = DEFINITIONAL_REPRESENTATION('',(#16997),#17001); +#16997 = LINE('',#16998,#16999); +#16998 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#16999 = VECTOR('',#17000,1.); +#17000 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17001 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17002 = ORIENTED_EDGE('',*,*,#11473,.F.); +#17003 = ADVANCED_FACE('',(#17004),#8991,.T.); +#17004 = FACE_BOUND('',#17005,.T.); +#17005 = EDGE_LOOP('',(#17006,#17027,#17028,#17049)); +#17006 = ORIENTED_EDGE('',*,*,#17007,.F.); +#17007 = EDGE_CURVE('',#8976,#11921,#17008,.T.); +#17008 = SURFACE_CURVE('',#17009,(#17013,#17020),.PCURVE_S1.); +#17009 = LINE('',#17010,#17011); +#17010 = CARTESIAN_POINT('',(-22.55000000002,64.599999999996,31.5)); +#17011 = VECTOR('',#17012,1.); +#17012 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17013 = PCURVE('',#8991,#17014); +#17014 = DEFINITIONAL_REPRESENTATION('',(#17015),#17019); +#17015 = LINE('',#17016,#17017); +#17016 = CARTESIAN_POINT('',(3.449999999979,1.453218755801E-14)); +#17017 = VECTOR('',#17018,1.); +#17018 = DIRECTION('',(2.28663820792E-16,1.)); +#17019 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17020 = PCURVE('',#9019,#17021); +#17021 = DEFINITIONAL_REPRESENTATION('',(#17022),#17026); +#17022 = LINE('',#17023,#17024); +#17023 = CARTESIAN_POINT('',(35.355339059344,-7.276257848042E-14)); +#17024 = VECTOR('',#17025,1.); +#17025 = DIRECTION('',(-1.397496474763E-15,1.)); +#17026 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17027 = ORIENTED_EDGE('',*,*,#8973,.F.); +#17028 = ORIENTED_EDGE('',*,*,#17029,.F.); +#17029 = EDGE_CURVE('',#11873,#8974,#17030,.T.); +#17030 = SURFACE_CURVE('',#17031,(#17035,#17042),.PCURVE_S1.); +#17031 = LINE('',#17032,#17033); +#17032 = CARTESIAN_POINT('',(-19.55000000002,64.599999999996,31.5)); +#17033 = VECTOR('',#17034,1.); +#17034 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17035 = PCURVE('',#8991,#17036); +#17036 = DEFINITIONAL_REPRESENTATION('',(#17037),#17041); +#17037 = LINE('',#17038,#17039); +#17038 = CARTESIAN_POINT('',(6.449999999979,2.716887239113E-14)); +#17039 = VECTOR('',#17040,1.); +#17040 = DIRECTION('',(-2.28663820792E-16,-1.)); +#17041 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17042 = PCURVE('',#9073,#17043); +#17043 = DEFINITIONAL_REPRESENTATION('',(#17044),#17048); +#17044 = LINE('',#17045,#17046); +#17045 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#17046 = VECTOR('',#17047,1.); +#17047 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17049 = ORIENTED_EDGE('',*,*,#11943,.F.); +#17050 = ADVANCED_FACE('',(#17051),#9447,.T.); +#17051 = FACE_BOUND('',#17052,.T.); +#17052 = EDGE_LOOP('',(#17053,#17074,#17075,#17096)); +#17053 = ORIENTED_EDGE('',*,*,#17054,.F.); +#17054 = EDGE_CURVE('',#9432,#11545,#17055,.T.); +#17055 = SURFACE_CURVE('',#17056,(#17060,#17067),.PCURVE_S1.); +#17056 = LINE('',#17057,#17058); +#17057 = CARTESIAN_POINT('',(-26.,64.599999999996,28.949999999979)); +#17058 = VECTOR('',#17059,1.); +#17059 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17060 = PCURVE('',#9447,#17061); +#17061 = DEFINITIONAL_REPRESENTATION('',(#17062),#17066); +#17062 = LINE('',#17063,#17064); +#17063 = CARTESIAN_POINT('',(17.449999999979,1.842342554267E-14)); +#17064 = VECTOR('',#17065,1.); +#17065 = DIRECTION('',(-1.747694647186E-15,1.)); +#17066 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17067 = PCURVE('',#9475,#17068); +#17068 = DEFINITIONAL_REPRESENTATION('',(#17069),#17073); +#17069 = LINE('',#17070,#17071); +#17070 = CARTESIAN_POINT('',(31.749094475262,3.26856803501E-14)); +#17071 = VECTOR('',#17072,1.); +#17072 = DIRECTION('',(-1.397496474763E-15,1.)); +#17073 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17074 = ORIENTED_EDGE('',*,*,#9431,.F.); +#17075 = ORIENTED_EDGE('',*,*,#17076,.T.); +#17076 = EDGE_CURVE('',#9404,#11568,#17077,.T.); +#17077 = SURFACE_CURVE('',#17078,(#17082,#17089),.PCURVE_S1.); +#17078 = LINE('',#17079,#17080); +#17079 = CARTESIAN_POINT('',(-26.,64.599999999996,31.5)); +#17080 = VECTOR('',#17081,1.); +#17081 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17082 = PCURVE('',#9447,#17083); +#17083 = DEFINITIONAL_REPRESENTATION('',(#17084),#17088); +#17084 = LINE('',#17085,#17086); +#17085 = CARTESIAN_POINT('',(20.,-7.628365117959E-14)); +#17086 = VECTOR('',#17087,1.); +#17087 = DIRECTION('',(-1.747694647186E-15,1.)); +#17088 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17089 = PCURVE('',#9419,#17090); +#17090 = DEFINITIONAL_REPRESENTATION('',(#17091),#17095); +#17091 = LINE('',#17092,#17093); +#17092 = CARTESIAN_POINT('',(0.,0.)); +#17093 = VECTOR('',#17094,1.); +#17094 = DIRECTION('',(2.28663820792E-16,1.)); +#17095 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17096 = ORIENTED_EDGE('',*,*,#11567,.F.); +#17097 = ADVANCED_FACE('',(#17098),#9305,.T.); +#17098 = FACE_BOUND('',#17099,.T.); +#17099 = EDGE_LOOP('',(#17100,#17121,#17122,#17143)); +#17100 = ORIENTED_EDGE('',*,*,#17101,.F.); +#17101 = EDGE_CURVE('',#9290,#11827,#17102,.T.); +#17102 = SURFACE_CURVE('',#17103,(#17107,#17114),.PCURVE_S1.); +#17103 = LINE('',#17104,#17105); +#17104 = CARTESIAN_POINT('',(-26.,64.599999999996,16.949999999979)); +#17105 = VECTOR('',#17106,1.); +#17106 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17107 = PCURVE('',#9305,#17108); +#17108 = DEFINITIONAL_REPRESENTATION('',(#17109),#17113); +#17109 = LINE('',#17110,#17111); +#17110 = CARTESIAN_POINT('',(5.449999999979,1.019236833266E-14)); +#17111 = VECTOR('',#17112,1.); +#17112 = DIRECTION('',(-1.747694647186E-15,1.)); +#17113 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17114 = PCURVE('',#9333,#17115); +#17115 = DEFINITIONAL_REPRESENTATION('',(#17116),#17120); +#17116 = LINE('',#17117,#17118); +#17117 = CARTESIAN_POINT('',(14.778531726785,7.500136247259E-14)); +#17118 = VECTOR('',#17119,1.); +#17119 = DIRECTION('',(-1.397496474763E-15,1.)); +#17120 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17121 = ORIENTED_EDGE('',*,*,#9287,.F.); +#17122 = ORIENTED_EDGE('',*,*,#17123,.F.); +#17123 = EDGE_CURVE('',#11779,#9288,#17124,.T.); +#17124 = SURFACE_CURVE('',#17125,(#17129,#17136),.PCURVE_S1.); +#17125 = LINE('',#17126,#17127); +#17126 = CARTESIAN_POINT('',(-26.,64.599999999996,19.949999999979)); +#17127 = VECTOR('',#17128,1.); +#17128 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17129 = PCURVE('',#9305,#17130); +#17130 = DEFINITIONAL_REPRESENTATION('',(#17131),#17135); +#17131 = LINE('',#17132,#17133); +#17132 = CARTESIAN_POINT('',(8.449999999979,1.580284631397E-14)); +#17133 = VECTOR('',#17134,1.); +#17134 = DIRECTION('',(1.747694647186E-15,-1.)); +#17135 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17136 = PCURVE('',#9387,#17137); +#17137 = DEFINITIONAL_REPRESENTATION('',(#17138),#17142); +#17138 = LINE('',#17139,#17140); +#17139 = CARTESIAN_POINT('',(16.75843071415,4.196437177995E-14)); +#17140 = VECTOR('',#17141,1.); +#17141 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17142 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17143 = ORIENTED_EDGE('',*,*,#11849,.F.); +#17144 = ADVANCED_FACE('',(#17145),#9219,.T.); +#17145 = FACE_BOUND('',#17146,.T.); +#17146 = EDGE_LOOP('',(#17147,#17168,#17169,#17190)); +#17147 = ORIENTED_EDGE('',*,*,#17148,.F.); +#17148 = EDGE_CURVE('',#11708,#9202,#17149,.T.); +#17149 = SURFACE_CURVE('',#17150,(#17154,#17161),.PCURVE_S1.); +#17150 = LINE('',#17151,#17152); +#17151 = CARTESIAN_POINT('',(-26.,64.599999999996,13.949999999979)); +#17152 = VECTOR('',#17153,1.); +#17153 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17154 = PCURVE('',#9219,#17155); +#17155 = DEFINITIONAL_REPRESENTATION('',(#17156),#17160); +#17156 = LINE('',#17157,#17158); +#17157 = CARTESIAN_POINT('',(2.449999999979,4.581890351359E-15)); +#17158 = VECTOR('',#17159,1.); +#17159 = DIRECTION('',(1.747694647186E-15,-1.)); +#17160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17161 = PCURVE('',#9273,#17162); +#17162 = DEFINITIONAL_REPRESENTATION('',(#17163),#17167); +#17163 = LINE('',#17164,#17165); +#17164 = CARTESIAN_POINT('',(25.243712088389,5.60167854836E-14)); +#17165 = VECTOR('',#17166,1.); +#17166 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17167 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17168 = ORIENTED_EDGE('',*,*,#11755,.F.); +#17169 = ORIENTED_EDGE('',*,*,#17170,.F.); +#17170 = EDGE_CURVE('',#9204,#11733,#17171,.T.); +#17171 = SURFACE_CURVE('',#17172,(#17176,#17183),.PCURVE_S1.); +#17172 = LINE('',#17173,#17174); +#17173 = CARTESIAN_POINT('',(-26.,64.599999999996,11.5)); +#17174 = VECTOR('',#17175,1.); +#17175 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17176 = PCURVE('',#9219,#17177); +#17177 = DEFINITIONAL_REPRESENTATION('',(#17178),#17182); +#17178 = LINE('',#17179,#17180); +#17179 = CARTESIAN_POINT('',(0.,0.)); +#17180 = VECTOR('',#17181,1.); +#17181 = DIRECTION('',(-1.747694647186E-15,1.)); +#17182 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17183 = PCURVE('',#9247,#17184); +#17184 = DEFINITIONAL_REPRESENTATION('',(#17185),#17189); +#17185 = LINE('',#17186,#17187); +#17186 = CARTESIAN_POINT('',(48.000000000027,-3.234991317303E-15)); +#17187 = VECTOR('',#17188,1.); +#17188 = DIRECTION('',(-2.28663820792E-16,1.)); +#17189 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17190 = ORIENTED_EDGE('',*,*,#9201,.F.); +#17191 = ADVANCED_FACE('',(#17192),#9931,.T.); +#17192 = FACE_BOUND('',#17193,.T.); +#17193 = EDGE_LOOP('',(#17194,#17215,#17216,#17217)); +#17194 = ORIENTED_EDGE('',*,*,#17195,.F.); +#17195 = EDGE_CURVE('',#12274,#9888,#17196,.T.); +#17196 = SURFACE_CURVE('',#17197,(#17201,#17208),.PCURVE_S1.); +#17197 = LINE('',#17198,#17199); +#17198 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 28.949999999951)); +#17199 = VECTOR('',#17200,1.); +#17200 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17201 = PCURVE('',#9931,#17202); +#17202 = DEFINITIONAL_REPRESENTATION('',(#17203),#17207); +#17203 = LINE('',#17204,#17205); +#17204 = CARTESIAN_POINT('',(2.550000000049,9.470707672222E-14)); +#17205 = VECTOR('',#17206,1.); +#17206 = DIRECTION('',(-1.747694647186E-15,-1.)); +#17207 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17208 = PCURVE('',#9903,#17209); +#17209 = DEFINITIONAL_REPRESENTATION('',(#17210),#17214); +#17210 = LINE('',#17211,#17212); +#17211 = CARTESIAN_POINT('',(31.749094475224,3.268568035016E-14)); +#17212 = VECTOR('',#17213,1.); +#17213 = DIRECTION('',(1.397496474763E-15,-1.)); +#17214 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17215 = ORIENTED_EDGE('',*,*,#12273,.F.); +#17216 = ORIENTED_EDGE('',*,*,#16700,.F.); +#17217 = ORIENTED_EDGE('',*,*,#9915,.F.); +#17218 = ADVANCED_FACE('',(#17219),#8677,.T.); +#17219 = FACE_BOUND('',#17220,.T.); +#17220 = EDGE_LOOP('',(#17221,#17242,#17243,#17264)); +#17221 = ORIENTED_EDGE('',*,*,#17222,.F.); +#17222 = EDGE_CURVE('',#11217,#8634,#17223,.T.); +#17223 = SURFACE_CURVE('',#17224,(#17228,#17235),.PCURVE_S1.); +#17224 = LINE('',#17225,#17226); +#17225 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 22.949999999951)); +#17226 = VECTOR('',#17227,1.); +#17227 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17228 = PCURVE('',#8677,#17229); +#17229 = DEFINITIONAL_REPRESENTATION('',(#17230),#17234); +#17230 = LINE('',#17231,#17232); +#17231 = CARTESIAN_POINT('',(8.550000000049,8.348612075961E-14)); +#17232 = VECTOR('',#17233,1.); +#17233 = DIRECTION('',(-1.747694647186E-15,-1.)); +#17234 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17235 = PCURVE('',#8649,#17236); +#17236 = DEFINITIONAL_REPRESENTATION('',(#17237),#17241); +#17237 = LINE('',#17238,#17239); +#17238 = CARTESIAN_POINT('',(23.263813100985,4.67380940538E-14)); +#17239 = VECTOR('',#17240,1.); +#17240 = DIRECTION('',(1.397496474763E-15,-1.)); +#17241 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17242 = ORIENTED_EDGE('',*,*,#11216,.F.); +#17243 = ORIENTED_EDGE('',*,*,#17244,.F.); +#17244 = EDGE_CURVE('',#8662,#11194,#17245,.T.); +#17245 = SURFACE_CURVE('',#17246,(#17250,#17257),.PCURVE_S1.); +#17246 = LINE('',#17247,#17248); +#17247 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 25.949999999952)); +#17248 = VECTOR('',#17249,1.); +#17249 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17250 = PCURVE('',#8677,#17251); +#17251 = DEFINITIONAL_REPRESENTATION('',(#17252),#17256); +#17252 = LINE('',#17253,#17254); +#17253 = CARTESIAN_POINT('',(5.550000000048,8.909659874091E-14)); +#17254 = VECTOR('',#17255,1.); +#17255 = DIRECTION('',(1.747694647186E-15,1.)); +#17256 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17257 = PCURVE('',#8703,#17258); +#17258 = DEFINITIONAL_REPRESENTATION('',(#17259),#17263); +#17259 = LINE('',#17260,#17261); +#17260 = CARTESIAN_POINT('',(8.27314933995,1.370110336117E-14)); +#17261 = VECTOR('',#17262,1.); +#17262 = DIRECTION('',(1.397496474763E-15,1.)); +#17263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17264 = ORIENTED_EDGE('',*,*,#8661,.F.); +#17265 = ADVANCED_FACE('',(#17266),#9845,.T.); +#17266 = FACE_BOUND('',#17267,.T.); +#17267 = EDGE_LOOP('',(#17268,#17289,#17290,#17311)); +#17268 = ORIENTED_EDGE('',*,*,#17269,.F.); +#17269 = EDGE_CURVE('',#12180,#9802,#17270,.T.); +#17270 = SURFACE_CURVE('',#17271,(#17275,#17282),.PCURVE_S1.); +#17271 = LINE('',#17272,#17273); +#17272 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 16.949999999951)); +#17273 = VECTOR('',#17274,1.); +#17274 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17275 = PCURVE('',#9845,#17276); +#17276 = DEFINITIONAL_REPRESENTATION('',(#17277),#17281); +#17277 = LINE('',#17278,#17279); +#17278 = CARTESIAN_POINT('',(14.550000000049,8.64760195122E-14)); +#17279 = VECTOR('',#17280,1.); +#17280 = DIRECTION('',(-1.747694647186E-15,-1.)); +#17281 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17282 = PCURVE('',#9817,#17283); +#17283 = DEFINITIONAL_REPRESENTATION('',(#17284),#17288); +#17284 = LINE('',#17285,#17286); +#17285 = CARTESIAN_POINT('',(14.778531726747,7.500136247265E-14)); +#17286 = VECTOR('',#17287,1.); +#17287 = DIRECTION('',(1.397496474763E-15,-1.)); +#17288 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17289 = ORIENTED_EDGE('',*,*,#12179,.F.); +#17290 = ORIENTED_EDGE('',*,*,#17291,.F.); +#17291 = EDGE_CURVE('',#9830,#12157,#17292,.T.); +#17292 = SURFACE_CURVE('',#17293,(#17297,#17304),.PCURVE_S1.); +#17293 = LINE('',#17294,#17295); +#17294 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 19.949999999952)); +#17295 = VECTOR('',#17296,1.); +#17296 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17297 = PCURVE('',#9845,#17298); +#17298 = DEFINITIONAL_REPRESENTATION('',(#17299),#17303); +#17299 = LINE('',#17300,#17301); +#17300 = CARTESIAN_POINT('',(11.550000000048,-7.389485512906E-15)); +#17301 = VECTOR('',#17302,1.); +#17302 = DIRECTION('',(1.747694647186E-15,1.)); +#17303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17304 = PCURVE('',#9871,#17305); +#17305 = DEFINITIONAL_REPRESENTATION('',(#17306),#17310); +#17306 = LINE('',#17307,#17308); +#17307 = CARTESIAN_POINT('',(16.758430714189,-5.75116112264E-14)); +#17308 = VECTOR('',#17309,1.); +#17309 = DIRECTION('',(1.397496474763E-15,1.)); +#17310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17311 = ORIENTED_EDGE('',*,*,#9829,.F.); +#17312 = ADVANCED_FACE('',(#17313),#8819,.T.); +#17313 = FACE_BOUND('',#17314,.T.); +#17314 = EDGE_LOOP('',(#17315,#17336,#17337,#17358)); +#17315 = ORIENTED_EDGE('',*,*,#17316,.F.); +#17316 = EDGE_CURVE('',#8804,#11288,#17317,.T.); +#17317 = SURFACE_CURVE('',#17318,(#17322,#17329),.PCURVE_S1.); +#17318 = LINE('',#17319,#17320); +#17319 = CARTESIAN_POINT('',(22.000000000023,64.599999999996, + 13.949999999952)); +#17320 = VECTOR('',#17321,1.); +#17321 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17322 = PCURVE('',#8819,#17323); +#17323 = DEFINITIONAL_REPRESENTATION('',(#17324),#17328); +#17324 = LINE('',#17325,#17326); +#17325 = CARTESIAN_POINT('',(17.550000000048,-1.861044147551E-14)); +#17326 = VECTOR('',#17327,1.); +#17327 = DIRECTION('',(1.747694647186E-15,1.)); +#17328 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17329 = PCURVE('',#8845,#17330); +#17330 = DEFINITIONAL_REPRESENTATION('',(#17331),#17335); +#17331 = LINE('',#17332,#17333); +#17332 = CARTESIAN_POINT('',(25.243712088427,-4.345919752275E-14)); +#17333 = VECTOR('',#17334,1.); +#17334 = DIRECTION('',(1.397496474763E-15,1.)); +#17335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17336 = ORIENTED_EDGE('',*,*,#8803,.F.); +#17337 = ORIENTED_EDGE('',*,*,#17338,.T.); +#17338 = EDGE_CURVE('',#8776,#11311,#17339,.T.); +#17339 = SURFACE_CURVE('',#17340,(#17344,#17351),.PCURVE_S1.); +#17340 = LINE('',#17341,#17342); +#17341 = CARTESIAN_POINT('',(22.000000000023,64.599999999996,11.5)); +#17342 = VECTOR('',#17343,1.); +#17343 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17344 = PCURVE('',#8819,#17345); +#17345 = DEFINITIONAL_REPRESENTATION('',(#17346),#17350); +#17346 = LINE('',#17347,#17348); +#17347 = CARTESIAN_POINT('',(20.,7.628365117959E-14)); +#17348 = VECTOR('',#17349,1.); +#17349 = DIRECTION('',(1.747694647186E-15,1.)); +#17350 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17351 = PCURVE('',#8791,#17352); +#17352 = DEFINITIONAL_REPRESENTATION('',(#17353),#17357); +#17353 = LINE('',#17354,#17355); +#17354 = CARTESIAN_POINT('',(0.,0.)); +#17355 = VECTOR('',#17356,1.); +#17356 = DIRECTION('',(-2.28663820792E-16,1.)); +#17357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17358 = ORIENTED_EDGE('',*,*,#11310,.F.); +#17359 = ADVANCED_FACE('',(#17360),#8791,.T.); +#17360 = FACE_BOUND('',#17361,.T.); +#17361 = EDGE_LOOP('',(#17362,#17383,#17384,#17385)); +#17362 = ORIENTED_EDGE('',*,*,#17363,.F.); +#17363 = EDGE_CURVE('',#11334,#8748,#17364,.T.); +#17364 = SURFACE_CURVE('',#17365,(#17369,#17376),.PCURVE_S1.); +#17365 = LINE('',#17366,#17367); +#17366 = CARTESIAN_POINT('',(21.449999999974,64.599999999996,11.5)); +#17367 = VECTOR('',#17368,1.); +#17368 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17369 = PCURVE('',#8791,#17370); +#17370 = DEFINITIONAL_REPRESENTATION('',(#17371),#17375); +#17371 = LINE('',#17372,#17373); +#17372 = CARTESIAN_POINT('',(0.550000000049,-2.316725552945E-15)); +#17373 = VECTOR('',#17374,1.); +#17374 = DIRECTION('',(2.28663820792E-16,-1.)); +#17375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17376 = PCURVE('',#8763,#17377); +#17377 = DEFINITIONAL_REPRESENTATION('',(#17378),#17382); +#17378 = LINE('',#17379,#17380); +#17379 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17380 = VECTOR('',#17381,1.); +#17381 = DIRECTION('',(1.397496474763E-15,-1.)); +#17382 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17383 = ORIENTED_EDGE('',*,*,#11333,.F.); +#17384 = ORIENTED_EDGE('',*,*,#17338,.F.); +#17385 = ORIENTED_EDGE('',*,*,#8775,.F.); +#17386 = ADVANCED_FACE('',(#17387),#9731,.T.); +#17387 = FACE_BOUND('',#17388,.T.); +#17388 = EDGE_LOOP('',(#17389,#17410,#17411,#17432)); +#17389 = ORIENTED_EDGE('',*,*,#17390,.F.); +#17390 = EDGE_CURVE('',#12086,#9688,#17391,.T.); +#17391 = SURFACE_CURVE('',#17392,(#17396,#17403),.PCURVE_S1.); +#17392 = LINE('',#17393,#17394); +#17393 = CARTESIAN_POINT('',(15.449999999974,64.599999999996,11.5)); +#17394 = VECTOR('',#17395,1.); +#17395 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17396 = PCURVE('',#9731,#17397); +#17397 = DEFINITIONAL_REPRESENTATION('',(#17398),#17402); +#17398 = LINE('',#17399,#17400); +#17399 = CARTESIAN_POINT('',(6.550000000049,-2.75900952192E-14)); +#17400 = VECTOR('',#17401,1.); +#17401 = DIRECTION('',(2.28663820792E-16,-1.)); +#17402 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17403 = PCURVE('',#9703,#17404); +#17404 = DEFINITIONAL_REPRESENTATION('',(#17405),#17409); +#17405 = LINE('',#17406,#17407); +#17406 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17407 = VECTOR('',#17408,1.); +#17408 = DIRECTION('',(1.397496474763E-15,-1.)); +#17409 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17410 = ORIENTED_EDGE('',*,*,#12085,.F.); +#17411 = ORIENTED_EDGE('',*,*,#17412,.F.); +#17412 = EDGE_CURVE('',#9716,#12063,#17413,.T.); +#17413 = SURFACE_CURVE('',#17414,(#17418,#17425),.PCURVE_S1.); +#17414 = LINE('',#17415,#17416); +#17415 = CARTESIAN_POINT('',(18.449999999975,64.599999999996,11.5)); +#17416 = VECTOR('',#17417,1.); +#17417 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17418 = PCURVE('',#9731,#17419); +#17419 = DEFINITIONAL_REPRESENTATION('',(#17420),#17424); +#17420 = LINE('',#17421,#17422); +#17421 = CARTESIAN_POINT('',(3.550000000048,-1.495341038607E-14)); +#17422 = VECTOR('',#17423,1.); +#17423 = DIRECTION('',(-2.28663820792E-16,1.)); +#17424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17425 = PCURVE('',#9757,#17426); +#17426 = DEFINITIONAL_REPRESENTATION('',(#17427),#17431); +#17427 = LINE('',#17428,#17429); +#17428 = CARTESIAN_POINT('',(28.708535316173,6.175485441254E-14)); +#17429 = VECTOR('',#17430,1.); +#17430 = DIRECTION('',(1.397496474763E-15,1.)); +#17431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17432 = ORIENTED_EDGE('',*,*,#9715,.F.); +#17433 = ADVANCED_FACE('',(#17434),#8933,.T.); +#17434 = FACE_BOUND('',#17435,.T.); +#17435 = EDGE_LOOP('',(#17436,#17457,#17458,#17479)); +#17436 = ORIENTED_EDGE('',*,*,#17437,.F.); +#17437 = EDGE_CURVE('',#11992,#8890,#17438,.T.); +#17438 = SURFACE_CURVE('',#17439,(#17443,#17450),.PCURVE_S1.); +#17439 = LINE('',#17440,#17441); +#17440 = CARTESIAN_POINT('',(9.449999999974,64.599999999996,11.5)); +#17441 = VECTOR('',#17442,1.); +#17442 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17443 = PCURVE('',#8933,#17444); +#17444 = DEFINITIONAL_REPRESENTATION('',(#17445),#17449); +#17445 = LINE('',#17446,#17447); +#17446 = CARTESIAN_POINT('',(12.550000000049,-5.286346488545E-14)); +#17447 = VECTOR('',#17448,1.); +#17448 = DIRECTION('',(2.28663820792E-16,-1.)); +#17449 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17450 = PCURVE('',#8905,#17451); +#17451 = DEFINITIONAL_REPRESENTATION('',(#17452),#17456); +#17452 = LINE('',#17453,#17454); +#17453 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17454 = VECTOR('',#17455,1.); +#17455 = DIRECTION('',(1.397496474763E-15,-1.)); +#17456 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17457 = ORIENTED_EDGE('',*,*,#11991,.F.); +#17458 = ORIENTED_EDGE('',*,*,#17459,.F.); +#17459 = EDGE_CURVE('',#8918,#11969,#17460,.T.); +#17460 = SURFACE_CURVE('',#17461,(#17465,#17472),.PCURVE_S1.); +#17461 = LINE('',#17462,#17463); +#17462 = CARTESIAN_POINT('',(12.449999999975,64.599999999996,11.5)); +#17463 = VECTOR('',#17464,1.); +#17464 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17465 = PCURVE('',#8933,#17466); +#17466 = DEFINITIONAL_REPRESENTATION('',(#17467),#17471); +#17467 = LINE('',#17468,#17469); +#17468 = CARTESIAN_POINT('',(9.550000000048,-4.022678005232E-14)); +#17469 = VECTOR('',#17470,1.); +#17470 = DIRECTION('',(-2.28663820792E-16,1.)); +#17471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17472 = PCURVE('',#8959,#17473); +#17473 = DEFINITIONAL_REPRESENTATION('',(#17474),#17478); +#17474 = LINE('',#17475,#17476); +#17475 = CARTESIAN_POINT('',(28.708535316173,-3.772112859388E-14)); +#17476 = VECTOR('',#17477,1.); +#17477 = DIRECTION('',(1.397496474763E-15,1.)); +#17478 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17479 = ORIENTED_EDGE('',*,*,#8917,.F.); +#17480 = ADVANCED_FACE('',(#17481),#9247,.T.); +#17481 = FACE_BOUND('',#17482,.T.); +#17482 = EDGE_LOOP('',(#17483,#17504,#17505,#17506)); +#17483 = ORIENTED_EDGE('',*,*,#17484,.F.); +#17484 = EDGE_CURVE('',#9232,#11710,#17485,.T.); +#17485 = SURFACE_CURVE('',#17486,(#17490,#17497),.PCURVE_S1.); +#17486 = LINE('',#17487,#17488); +#17487 = CARTESIAN_POINT('',(-23.55000000002,64.599999999996,11.5)); +#17488 = VECTOR('',#17489,1.); +#17489 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17490 = PCURVE('',#9247,#17491); +#17491 = DEFINITIONAL_REPRESENTATION('',(#17492),#17496); +#17492 = LINE('',#17493,#17494); +#17493 = CARTESIAN_POINT('',(45.550000000048,7.084967962996E-15)); +#17494 = VECTOR('',#17495,1.); +#17495 = DIRECTION('',(-2.28663820792E-16,1.)); +#17496 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17497 = PCURVE('',#9273,#17498); +#17498 = DEFINITIONAL_REPRESENTATION('',(#17499),#17503); +#17499 = LINE('',#17500,#17501); +#17500 = CARTESIAN_POINT('',(28.708535316173,6.175485441254E-14)); +#17501 = VECTOR('',#17502,1.); +#17502 = DIRECTION('',(1.397496474763E-15,1.)); +#17503 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17504 = ORIENTED_EDGE('',*,*,#9231,.F.); +#17505 = ORIENTED_EDGE('',*,*,#17170,.T.); +#17506 = ORIENTED_EDGE('',*,*,#11732,.F.); +#17507 = ADVANCED_FACE('',(#17508),#9617,.T.); +#17508 = FACE_BOUND('',#17509,.T.); +#17509 = EDGE_LOOP('',(#17510,#17531,#17532,#17553)); +#17510 = ORIENTED_EDGE('',*,*,#17511,.F.); +#17511 = EDGE_CURVE('',#11428,#9574,#17512,.T.); +#17512 = SURFACE_CURVE('',#17513,(#17517,#17524),.PCURVE_S1.); +#17513 = LINE('',#17514,#17515); +#17514 = CARTESIAN_POINT('',(3.449999999974,64.599999999996,11.5)); +#17515 = VECTOR('',#17516,1.); +#17516 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17517 = PCURVE('',#9617,#17518); +#17518 = DEFINITIONAL_REPRESENTATION('',(#17519),#17523); +#17519 = LINE('',#17520,#17521); +#17520 = CARTESIAN_POINT('',(18.550000000049,2.133914845471E-14)); +#17521 = VECTOR('',#17522,1.); +#17522 = DIRECTION('',(2.28663820792E-16,-1.)); +#17523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17524 = PCURVE('',#9589,#17525); +#17525 = DEFINITIONAL_REPRESENTATION('',(#17526),#17530); +#17526 = LINE('',#17527,#17528); +#17527 = CARTESIAN_POINT('',(7.071067811882,8.776563825335E-14)); +#17528 = VECTOR('',#17529,1.); +#17529 = DIRECTION('',(1.397496474763E-15,-1.)); +#17530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17531 = ORIENTED_EDGE('',*,*,#11427,.F.); +#17532 = ORIENTED_EDGE('',*,*,#17533,.F.); +#17533 = EDGE_CURVE('',#9602,#11405,#17534,.T.); +#17534 = SURFACE_CURVE('',#17535,(#17539,#17546),.PCURVE_S1.); +#17535 = LINE('',#17536,#17537); +#17536 = CARTESIAN_POINT('',(6.449999999975,64.599999999996,11.5)); +#17537 = VECTOR('',#17538,1.); +#17538 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17539 = PCURVE('',#9617,#17540); +#17540 = DEFINITIONAL_REPRESENTATION('',(#17541),#17545); +#17541 = LINE('',#17542,#17543); +#17542 = CARTESIAN_POINT('',(15.550000000048,-6.550014971857E-14)); +#17543 = VECTOR('',#17544,1.); +#17544 = DIRECTION('',(-2.28663820792E-16,1.)); +#17545 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17546 = PCURVE('',#9643,#17547); +#17547 = DEFINITIONAL_REPRESENTATION('',(#17548),#17552); +#17548 = LINE('',#17549,#17550); +#17549 = CARTESIAN_POINT('',(28.708535316173,-3.772112859388E-14)); +#17550 = VECTOR('',#17551,1.); +#17551 = DIRECTION('',(1.397496474763E-15,1.)); +#17552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17553 = ORIENTED_EDGE('',*,*,#9601,.F.); +#17554 = ADVANCED_FACE('',(#17555),#9361,.T.); +#17555 = FACE_BOUND('',#17556,.T.); +#17556 = EDGE_LOOP('',(#17557,#17578,#17579,#17600)); +#17557 = ORIENTED_EDGE('',*,*,#17558,.F.); +#17558 = EDGE_CURVE('',#9346,#11781,#17559,.T.); +#17559 = SURFACE_CURVE('',#17560,(#17564,#17571),.PCURVE_S1.); +#17560 = LINE('',#17561,#17562); +#17561 = CARTESIAN_POINT('',(-17.55000000002,64.599999999996,11.5)); +#17562 = VECTOR('',#17563,1.); +#17563 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17564 = PCURVE('',#9361,#17565); +#17565 = DEFINITIONAL_REPRESENTATION('',(#17566),#17570); +#17566 = LINE('',#17567,#17568); +#17567 = CARTESIAN_POINT('',(39.550000000048,-6.711764537717E-14)); +#17568 = VECTOR('',#17569,1.); +#17569 = DIRECTION('',(-2.28663820792E-16,1.)); +#17570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17571 = PCURVE('',#9387,#17572); +#17572 = DEFINITIONAL_REPRESENTATION('',(#17573),#17577); +#17573 = LINE('',#17574,#17575); +#17574 = CARTESIAN_POINT('',(28.708535316173,-3.772112859388E-14)); +#17575 = VECTOR('',#17576,1.); +#17576 = DIRECTION('',(1.397496474763E-15,1.)); +#17577 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17578 = ORIENTED_EDGE('',*,*,#9345,.F.); +#17579 = ORIENTED_EDGE('',*,*,#17580,.F.); +#17580 = EDGE_CURVE('',#11804,#9318,#17581,.T.); +#17581 = SURFACE_CURVE('',#17582,(#17586,#17593),.PCURVE_S1.); +#17582 = LINE('',#17583,#17584); +#17583 = CARTESIAN_POINT('',(-20.55000000002,64.599999999996,11.5)); +#17584 = VECTOR('',#17585,1.); +#17585 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17586 = PCURVE('',#9361,#17587); +#17587 = DEFINITIONAL_REPRESENTATION('',(#17588),#17592); +#17588 = LINE('',#17589,#17590); +#17589 = CARTESIAN_POINT('',(42.550000000049,1.972165279612E-14)); +#17590 = VECTOR('',#17591,1.); +#17591 = DIRECTION('',(2.28663820792E-16,-1.)); +#17592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17593 = PCURVE('',#9333,#17594); +#17594 = DEFINITIONAL_REPRESENTATION('',(#17595),#17599); +#17595 = LINE('',#17596,#17597); +#17596 = CARTESIAN_POINT('',(7.071067811882,8.776563825335E-14)); +#17597 = VECTOR('',#17598,1.); +#17598 = DIRECTION('',(1.397496474763E-15,-1.)); +#17599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17600 = ORIENTED_EDGE('',*,*,#11803,.F.); +#17601 = ADVANCED_FACE('',(#17602),#9047,.T.); +#17602 = FACE_BOUND('',#17603,.T.); +#17603 = EDGE_LOOP('',(#17604,#17625,#17626,#17647)); +#17604 = ORIENTED_EDGE('',*,*,#17605,.F.); +#17605 = EDGE_CURVE('',#11898,#9004,#17606,.T.); +#17606 = SURFACE_CURVE('',#17607,(#17611,#17618),.PCURVE_S1.); +#17607 = LINE('',#17608,#17609); +#17608 = CARTESIAN_POINT('',(-2.550000000026,64.599999999996,11.5)); +#17609 = VECTOR('',#17610,1.); +#17610 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17611 = PCURVE('',#9047,#17612); +#17612 = DEFINITIONAL_REPRESENTATION('',(#17613),#17617); +#17613 = LINE('',#17614,#17615); +#17614 = CARTESIAN_POINT('',(24.550000000049,-3.934221211539E-15)); +#17615 = VECTOR('',#17616,1.); +#17616 = DIRECTION('',(2.28663820792E-16,-1.)); +#17617 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17618 = PCURVE('',#9019,#17619); +#17619 = DEFINITIONAL_REPRESENTATION('',(#17620),#17624); +#17620 = LINE('',#17621,#17622); +#17621 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17622 = VECTOR('',#17623,1.); +#17623 = DIRECTION('',(1.397496474763E-15,-1.)); +#17624 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17625 = ORIENTED_EDGE('',*,*,#11897,.F.); +#17626 = ORIENTED_EDGE('',*,*,#17627,.F.); +#17627 = EDGE_CURVE('',#9032,#11875,#17628,.T.); +#17628 = SURFACE_CURVE('',#17629,(#17633,#17640),.PCURVE_S1.); +#17629 = LINE('',#17630,#17631); +#17630 = CARTESIAN_POINT('',(0.449999999975,64.599999999996,11.5)); +#17631 = VECTOR('',#17632,1.); +#17632 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17633 = PCURVE('',#9047,#17634); +#17634 = DEFINITIONAL_REPRESENTATION('',(#17635),#17639); +#17635 = LINE('',#17636,#17637); +#17636 = CARTESIAN_POINT('',(21.550000000048,8.70246362159E-15)); +#17637 = VECTOR('',#17638,1.); +#17638 = DIRECTION('',(-2.28663820792E-16,1.)); +#17639 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17640 = PCURVE('',#9073,#17641); +#17641 = DEFINITIONAL_REPRESENTATION('',(#17642),#17646); +#17642 = LINE('',#17643,#17644); +#17643 = CARTESIAN_POINT('',(28.708535316173,6.175485441254E-14)); +#17644 = VECTOR('',#17645,1.); +#17645 = DIRECTION('',(1.397496474763E-15,1.)); +#17646 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17647 = ORIENTED_EDGE('',*,*,#9031,.F.); +#17648 = ADVANCED_FACE('',(#17649),#9161,.T.); +#17649 = FACE_BOUND('',#17650,.T.); +#17650 = EDGE_LOOP('',(#17651,#17672,#17673,#17694)); +#17651 = ORIENTED_EDGE('',*,*,#17652,.F.); +#17652 = EDGE_CURVE('',#9146,#11616,#17653,.T.); +#17653 = SURFACE_CURVE('',#17654,(#17658,#17665),.PCURVE_S1.); +#17654 = LINE('',#17655,#17656); +#17655 = CARTESIAN_POINT('',(-11.55000000002,64.599999999996,11.5)); +#17656 = VECTOR('',#17657,1.); +#17657 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17658 = PCURVE('',#9161,#17659); +#17659 = DEFINITIONAL_REPRESENTATION('',(#17660),#17664); +#17660 = LINE('',#17661,#17662); +#17661 = CARTESIAN_POINT('',(33.550000000048,-4.184427571091E-14)); +#17662 = VECTOR('',#17663,1.); +#17663 = DIRECTION('',(-2.28663820792E-16,1.)); +#17664 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17665 = PCURVE('',#9187,#17666); +#17666 = DEFINITIONAL_REPRESENTATION('',(#17667),#17671); +#17667 = LINE('',#17668,#17669); +#17668 = CARTESIAN_POINT('',(28.708535316173,-3.772112859388E-14)); +#17669 = VECTOR('',#17670,1.); +#17670 = DIRECTION('',(1.397496474763E-15,1.)); +#17671 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17672 = ORIENTED_EDGE('',*,*,#9145,.F.); +#17673 = ORIENTED_EDGE('',*,*,#17674,.F.); +#17674 = EDGE_CURVE('',#11639,#9118,#17675,.T.); +#17675 = SURFACE_CURVE('',#17676,(#17680,#17687),.PCURVE_S1.); +#17676 = LINE('',#17677,#17678); +#17677 = CARTESIAN_POINT('',(-14.55000000002,64.599999999996,11.5)); +#17678 = VECTOR('',#17679,1.); +#17679 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17680 = PCURVE('',#9161,#17681); +#17681 = DEFINITIONAL_REPRESENTATION('',(#17682),#17686); +#17682 = LINE('',#17683,#17684); +#17683 = CARTESIAN_POINT('',(36.550000000049,-5.448096054404E-14)); +#17684 = VECTOR('',#17685,1.); +#17685 = DIRECTION('',(2.28663820792E-16,-1.)); +#17686 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17687 = PCURVE('',#9133,#17688); +#17688 = DEFINITIONAL_REPRESENTATION('',(#17689),#17693); +#17689 = LINE('',#17690,#17691); +#17690 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17691 = VECTOR('',#17692,1.); +#17692 = DIRECTION('',(1.397496474763E-15,-1.)); +#17693 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17694 = ORIENTED_EDGE('',*,*,#11638,.F.); +#17695 = ADVANCED_FACE('',(#17696),#9419,.T.); +#17696 = FACE_BOUND('',#17697,.T.); +#17697 = EDGE_LOOP('',(#17698,#17719,#17720,#17721)); +#17698 = ORIENTED_EDGE('',*,*,#17699,.F.); +#17699 = EDGE_CURVE('',#11497,#9402,#17700,.T.); +#17700 = SURFACE_CURVE('',#17701,(#17705,#17712),.PCURVE_S1.); +#17701 = LINE('',#17702,#17703); +#17702 = CARTESIAN_POINT('',(-25.55000000002,64.599999999996,31.5)); +#17703 = VECTOR('',#17704,1.); +#17704 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17705 = PCURVE('',#9419,#17706); +#17706 = DEFINITIONAL_REPRESENTATION('',(#17707),#17711); +#17707 = LINE('',#17708,#17709); +#17708 = CARTESIAN_POINT('',(0.449999999979,1.89550272488E-15)); +#17709 = VECTOR('',#17710,1.); +#17710 = DIRECTION('',(-2.28663820792E-16,-1.)); +#17711 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17712 = PCURVE('',#9529,#17713); +#17713 = DEFINITIONAL_REPRESENTATION('',(#17714),#17718); +#17714 = LINE('',#17715,#17716); +#17715 = CARTESIAN_POINT('',(0.424264068711,7.026206851812E-16)); +#17716 = VECTOR('',#17717,1.); +#17717 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17718 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17719 = ORIENTED_EDGE('',*,*,#11590,.F.); +#17720 = ORIENTED_EDGE('',*,*,#17076,.F.); +#17721 = ORIENTED_EDGE('',*,*,#9401,.F.); +#17722 = ADVANCED_FACE('',(#17723),#9105,.T.); +#17723 = FACE_BOUND('',#17724,.T.); +#17724 = EDGE_LOOP('',(#17725,#17746,#17747,#17768)); +#17725 = ORIENTED_EDGE('',*,*,#17726,.F.); +#17726 = EDGE_CURVE('',#11614,#9088,#17727,.T.); +#17727 = SURFACE_CURVE('',#17728,(#17732,#17739),.PCURVE_S1.); +#17728 = LINE('',#17729,#17730); +#17729 = CARTESIAN_POINT('',(-26.,64.599999999996,25.949999999979)); +#17730 = VECTOR('',#17731,1.); +#17731 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17732 = PCURVE('',#9105,#17733); +#17733 = DEFINITIONAL_REPRESENTATION('',(#17734),#17738); +#17734 = LINE('',#17735,#17736); +#17735 = CARTESIAN_POINT('',(14.449999999979,1.281294756137E-14)); +#17736 = VECTOR('',#17737,1.); +#17737 = DIRECTION('',(1.747694647186E-15,-1.)); +#17738 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17739 = PCURVE('',#9187,#17740); +#17740 = DEFINITIONAL_REPRESENTATION('',(#17741),#17745); +#17741 = LINE('',#17742,#17743); +#17742 = CARTESIAN_POINT('',(8.273149339912,1.37011033611E-14)); +#17743 = VECTOR('',#17744,1.); +#17744 = DIRECTION('',(-1.397496474763E-15,-1.)); +#17745 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17746 = ORIENTED_EDGE('',*,*,#11684,.F.); +#17747 = ORIENTED_EDGE('',*,*,#17748,.F.); +#17748 = EDGE_CURVE('',#9090,#11662,#17749,.T.); +#17749 = SURFACE_CURVE('',#17750,(#17754,#17761),.PCURVE_S1.); +#17750 = LINE('',#17751,#17752); +#17751 = CARTESIAN_POINT('',(-26.,64.599999999996,22.949999999979)); +#17752 = VECTOR('',#17753,1.); +#17753 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17754 = PCURVE('',#9105,#17755); +#17755 = DEFINITIONAL_REPRESENTATION('',(#17756),#17760); +#17756 = LINE('',#17757,#17758); +#17757 = CARTESIAN_POINT('',(11.449999999979,7.202469580066E-15)); +#17758 = VECTOR('',#17759,1.); +#17759 = DIRECTION('',(-1.747694647186E-15,1.)); +#17760 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17761 = PCURVE('',#9133,#17762); +#17762 = DEFINITIONAL_REPRESENTATION('',(#17763),#17767); +#17763 = LINE('',#17764,#17765); +#17764 = CARTESIAN_POINT('',(23.263813101024,4.673809405374E-14)); +#17765 = VECTOR('',#17766,1.); +#17766 = DIRECTION('',(-1.397496474763E-15,1.)); +#17767 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17768 = ORIENTED_EDGE('',*,*,#9087,.F.); +#17769 = ADVANCED_FACE('',(#17770),#9503,.T.); +#17770 = FACE_BOUND('',#17771,.T.); +#17771 = EDGE_LOOP('',(#17772,#17793,#17794,#17815)); +#17772 = ORIENTED_EDGE('',*,*,#17773,.F.); +#17773 = EDGE_CURVE('',#11522,#9460,#17774,.T.); +#17774 = SURFACE_CURVE('',#17775,(#17779,#17786),.PCURVE_S1.); +#17775 = LINE('',#17776,#17777); +#17776 = CARTESIAN_POINT('',(-8.550000000026,64.599999999996,11.5)); +#17777 = VECTOR('',#17778,1.); +#17778 = DIRECTION('',(-4.440892098501E-15,1.,-1.224646799147E-16)); +#17779 = PCURVE('',#9503,#17780); +#17780 = DEFINITIONAL_REPRESENTATION('',(#17781),#17785); +#17781 = LINE('',#17782,#17783); +#17782 = CARTESIAN_POINT('',(30.550000000049,-2.920759087779E-14)); +#17783 = VECTOR('',#17784,1.); +#17784 = DIRECTION('',(2.28663820792E-16,-1.)); +#17785 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17786 = PCURVE('',#9475,#17787); +#17787 = DEFINITIONAL_REPRESENTATION('',(#17788),#17792); +#17788 = LINE('',#17789,#17790); +#17789 = CARTESIAN_POINT('',(7.071067811882,-1.171034475307E-14)); +#17790 = VECTOR('',#17791,1.); +#17791 = DIRECTION('',(1.397496474763E-15,-1.)); +#17792 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17793 = ORIENTED_EDGE('',*,*,#11521,.F.); +#17794 = ORIENTED_EDGE('',*,*,#17795,.F.); +#17795 = EDGE_CURVE('',#9488,#11499,#17796,.T.); +#17796 = SURFACE_CURVE('',#17797,(#17801,#17808),.PCURVE_S1.); +#17797 = LINE('',#17798,#17799); +#17798 = CARTESIAN_POINT('',(-5.550000000025,64.599999999996,11.5)); +#17799 = VECTOR('',#17800,1.); +#17800 = DIRECTION('',(4.440892098501E-15,-1.,1.224646799147E-16)); +#17801 = PCURVE('',#9503,#17802); +#17802 = DEFINITIONAL_REPRESENTATION('',(#17803),#17807); +#17803 = LINE('',#17804,#17805); +#17804 = CARTESIAN_POINT('',(27.550000000048,-1.657090604466E-14)); +#17805 = VECTOR('',#17806,1.); +#17806 = DIRECTION('',(-2.28663820792E-16,1.)); +#17807 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17808 = PCURVE('',#9529,#17809); +#17809 = DEFINITIONAL_REPRESENTATION('',(#17810),#17814); +#17810 = LINE('',#17811,#17812); +#17811 = CARTESIAN_POINT('',(28.708535316173,6.175485441254E-14)); +#17812 = VECTOR('',#17813,1.); +#17813 = DIRECTION('',(1.397496474763E-15,1.)); +#17814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17815 = ORIENTED_EDGE('',*,*,#9487,.F.); +#17816 = ADVANCED_FACE('',(#17817),#8845,.T.); +#17817 = FACE_BOUND('',#17818,.T.); +#17818 = EDGE_LOOP('',(#17819,#17820,#17821,#17822)); +#17819 = ORIENTED_EDGE('',*,*,#16841,.T.); +#17820 = ORIENTED_EDGE('',*,*,#8831,.T.); +#17821 = ORIENTED_EDGE('',*,*,#17316,.T.); +#17822 = ORIENTED_EDGE('',*,*,#11285,.F.); +#17823 = ADVANCED_FACE('',(#17824),#9871,.T.); +#17824 = FACE_BOUND('',#17825,.T.); +#17825 = EDGE_LOOP('',(#17826,#17827,#17828,#17829)); +#17826 = ORIENTED_EDGE('',*,*,#16794,.T.); +#17827 = ORIENTED_EDGE('',*,*,#9857,.T.); +#17828 = ORIENTED_EDGE('',*,*,#17291,.T.); +#17829 = ORIENTED_EDGE('',*,*,#12154,.F.); +#17830 = ADVANCED_FACE('',(#17831),#8703,.T.); +#17831 = FACE_BOUND('',#17832,.T.); +#17832 = EDGE_LOOP('',(#17833,#17834,#17835,#17836)); +#17833 = ORIENTED_EDGE('',*,*,#16747,.T.); +#17834 = ORIENTED_EDGE('',*,*,#8689,.T.); +#17835 = ORIENTED_EDGE('',*,*,#17244,.T.); +#17836 = ORIENTED_EDGE('',*,*,#11191,.F.); +#17837 = ADVANCED_FACE('',(#17838),#9187,.T.); +#17838 = FACE_BOUND('',#17839,.T.); +#17839 = EDGE_LOOP('',(#17840,#17841,#17842,#17843)); +#17840 = ORIENTED_EDGE('',*,*,#17726,.T.); +#17841 = ORIENTED_EDGE('',*,*,#9173,.T.); +#17842 = ORIENTED_EDGE('',*,*,#17652,.T.); +#17843 = ORIENTED_EDGE('',*,*,#11613,.F.); +#17844 = ADVANCED_FACE('',(#17845),#9529,.T.); +#17845 = FACE_BOUND('',#17846,.T.); +#17846 = EDGE_LOOP('',(#17847,#17848,#17849,#17850)); +#17847 = ORIENTED_EDGE('',*,*,#17699,.T.); +#17848 = ORIENTED_EDGE('',*,*,#9515,.T.); +#17849 = ORIENTED_EDGE('',*,*,#17795,.T.); +#17850 = ORIENTED_EDGE('',*,*,#11496,.F.); +#17851 = ADVANCED_FACE('',(#17852),#9073,.T.); +#17852 = FACE_BOUND('',#17853,.T.); +#17853 = EDGE_LOOP('',(#17854,#17855,#17856,#17857)); +#17854 = ORIENTED_EDGE('',*,*,#17029,.T.); +#17855 = ORIENTED_EDGE('',*,*,#9059,.T.); +#17856 = ORIENTED_EDGE('',*,*,#17627,.T.); +#17857 = ORIENTED_EDGE('',*,*,#11872,.F.); +#17858 = ADVANCED_FACE('',(#17859),#9643,.T.); +#17859 = FACE_BOUND('',#17860,.T.); +#17860 = EDGE_LOOP('',(#17861,#17862,#17863,#17864)); +#17861 = ORIENTED_EDGE('',*,*,#16982,.T.); +#17862 = ORIENTED_EDGE('',*,*,#9629,.T.); +#17863 = ORIENTED_EDGE('',*,*,#17533,.T.); +#17864 = ORIENTED_EDGE('',*,*,#11402,.F.); +#17865 = ADVANCED_FACE('',(#17866),#8959,.T.); +#17866 = FACE_BOUND('',#17867,.T.); +#17867 = EDGE_LOOP('',(#17868,#17869,#17870,#17871)); +#17868 = ORIENTED_EDGE('',*,*,#16935,.T.); +#17869 = ORIENTED_EDGE('',*,*,#8945,.T.); +#17870 = ORIENTED_EDGE('',*,*,#17459,.T.); +#17871 = ORIENTED_EDGE('',*,*,#11966,.F.); +#17872 = ADVANCED_FACE('',(#17873),#9757,.T.); +#17873 = FACE_BOUND('',#17874,.T.); +#17874 = EDGE_LOOP('',(#17875,#17876,#17877,#17878)); +#17875 = ORIENTED_EDGE('',*,*,#16888,.T.); +#17876 = ORIENTED_EDGE('',*,*,#9743,.T.); +#17877 = ORIENTED_EDGE('',*,*,#17412,.T.); +#17878 = ORIENTED_EDGE('',*,*,#12060,.F.); +#17879 = ADVANCED_FACE('',(#17880),#9273,.T.); +#17880 = FACE_BOUND('',#17881,.T.); +#17881 = EDGE_LOOP('',(#17882,#17883,#17884,#17885)); +#17882 = ORIENTED_EDGE('',*,*,#17148,.T.); +#17883 = ORIENTED_EDGE('',*,*,#9259,.T.); +#17884 = ORIENTED_EDGE('',*,*,#17484,.T.); +#17885 = ORIENTED_EDGE('',*,*,#11707,.F.); +#17886 = ADVANCED_FACE('',(#17887),#9333,.T.); +#17887 = FACE_BOUND('',#17888,.T.); +#17888 = EDGE_LOOP('',(#17889,#17890,#17891,#17892)); +#17889 = ORIENTED_EDGE('',*,*,#17101,.T.); +#17890 = ORIENTED_EDGE('',*,*,#11826,.F.); +#17891 = ORIENTED_EDGE('',*,*,#17580,.T.); +#17892 = ORIENTED_EDGE('',*,*,#9317,.F.); +#17893 = ADVANCED_FACE('',(#17894),#9387,.T.); +#17894 = FACE_BOUND('',#17895,.T.); +#17895 = EDGE_LOOP('',(#17896,#17897,#17898,#17899)); +#17896 = ORIENTED_EDGE('',*,*,#17123,.T.); +#17897 = ORIENTED_EDGE('',*,*,#9373,.T.); +#17898 = ORIENTED_EDGE('',*,*,#17558,.T.); +#17899 = ORIENTED_EDGE('',*,*,#11778,.F.); +#17900 = ADVANCED_FACE('',(#17901),#9133,.T.); +#17901 = FACE_BOUND('',#17902,.T.); +#17902 = EDGE_LOOP('',(#17903,#17904,#17905,#17906)); +#17903 = ORIENTED_EDGE('',*,*,#17748,.T.); +#17904 = ORIENTED_EDGE('',*,*,#11661,.F.); +#17905 = ORIENTED_EDGE('',*,*,#17674,.T.); +#17906 = ORIENTED_EDGE('',*,*,#9117,.F.); +#17907 = ADVANCED_FACE('',(#17908),#9475,.T.); +#17908 = FACE_BOUND('',#17909,.T.); +#17909 = EDGE_LOOP('',(#17910,#17911,#17912,#17913)); +#17910 = ORIENTED_EDGE('',*,*,#17054,.T.); +#17911 = ORIENTED_EDGE('',*,*,#11544,.F.); +#17912 = ORIENTED_EDGE('',*,*,#17773,.T.); +#17913 = ORIENTED_EDGE('',*,*,#9459,.F.); +#17914 = ADVANCED_FACE('',(#17915),#9019,.T.); +#17915 = FACE_BOUND('',#17916,.T.); +#17916 = EDGE_LOOP('',(#17917,#17918,#17919,#17920)); +#17917 = ORIENTED_EDGE('',*,*,#17007,.T.); +#17918 = ORIENTED_EDGE('',*,*,#11920,.F.); +#17919 = ORIENTED_EDGE('',*,*,#17605,.T.); +#17920 = ORIENTED_EDGE('',*,*,#9003,.F.); +#17921 = ADVANCED_FACE('',(#17922),#9589,.T.); +#17922 = FACE_BOUND('',#17923,.T.); +#17923 = EDGE_LOOP('',(#17924,#17925,#17926,#17927)); +#17924 = ORIENTED_EDGE('',*,*,#16960,.T.); +#17925 = ORIENTED_EDGE('',*,*,#11450,.F.); +#17926 = ORIENTED_EDGE('',*,*,#17511,.T.); +#17927 = ORIENTED_EDGE('',*,*,#9573,.F.); +#17928 = ADVANCED_FACE('',(#17929),#8905,.T.); +#17929 = FACE_BOUND('',#17930,.T.); +#17930 = EDGE_LOOP('',(#17931,#17932,#17933,#17934)); +#17931 = ORIENTED_EDGE('',*,*,#16913,.T.); +#17932 = ORIENTED_EDGE('',*,*,#12014,.F.); +#17933 = ORIENTED_EDGE('',*,*,#17437,.T.); +#17934 = ORIENTED_EDGE('',*,*,#8889,.F.); +#17935 = ADVANCED_FACE('',(#17936),#9703,.T.); +#17936 = FACE_BOUND('',#17937,.T.); +#17937 = EDGE_LOOP('',(#17938,#17939,#17940,#17941)); +#17938 = ORIENTED_EDGE('',*,*,#16866,.T.); +#17939 = ORIENTED_EDGE('',*,*,#12108,.F.); +#17940 = ORIENTED_EDGE('',*,*,#17390,.T.); +#17941 = ORIENTED_EDGE('',*,*,#9687,.F.); +#17942 = ADVANCED_FACE('',(#17943),#8763,.T.); +#17943 = FACE_BOUND('',#17944,.T.); +#17944 = EDGE_LOOP('',(#17945,#17946,#17947,#17948)); +#17945 = ORIENTED_EDGE('',*,*,#16819,.T.); +#17946 = ORIENTED_EDGE('',*,*,#11356,.F.); +#17947 = ORIENTED_EDGE('',*,*,#17363,.T.); +#17948 = ORIENTED_EDGE('',*,*,#8747,.F.); +#17949 = ADVANCED_FACE('',(#17950),#9817,.T.); +#17950 = FACE_BOUND('',#17951,.T.); +#17951 = EDGE_LOOP('',(#17952,#17953,#17954,#17955)); +#17952 = ORIENTED_EDGE('',*,*,#16772,.T.); +#17953 = ORIENTED_EDGE('',*,*,#12202,.F.); +#17954 = ORIENTED_EDGE('',*,*,#17269,.T.); +#17955 = ORIENTED_EDGE('',*,*,#9801,.F.); +#17956 = ADVANCED_FACE('',(#17957),#8649,.T.); +#17957 = FACE_BOUND('',#17958,.T.); +#17958 = EDGE_LOOP('',(#17959,#17960,#17961,#17962)); +#17959 = ORIENTED_EDGE('',*,*,#16725,.T.); +#17960 = ORIENTED_EDGE('',*,*,#11239,.F.); +#17961 = ORIENTED_EDGE('',*,*,#17222,.T.); +#17962 = ORIENTED_EDGE('',*,*,#8633,.F.); +#17963 = ADVANCED_FACE('',(#17964),#9903,.T.); +#17964 = FACE_BOUND('',#17965,.T.); +#17965 = EDGE_LOOP('',(#17966,#17967,#17968,#17969)); +#17966 = ORIENTED_EDGE('',*,*,#16678,.T.); +#17967 = ORIENTED_EDGE('',*,*,#12296,.F.); +#17968 = ORIENTED_EDGE('',*,*,#17195,.T.); +#17969 = ORIENTED_EDGE('',*,*,#9885,.F.); +#17970 = ADVANCED_FACE('',(#17971,#18614,#18708,#18802,#18896),#3842,.F. + ); +#17971 = FACE_BOUND('',#17972,.T.); +#17972 = EDGE_LOOP('',(#17973,#17998,#18021,#18042,#18043,#18044,#18067, + #18088,#18089,#18112,#18135,#18156,#18157,#18180,#18203,#18224, + #18225,#18248,#18271,#18292,#18293,#18294,#18317,#18340,#18363, + #18386,#18409,#18432,#18455,#18478,#18501,#18524,#18547,#18570, + #18593)); +#17973 = ORIENTED_EDGE('',*,*,#17974,.F.); +#17974 = EDGE_CURVE('',#17975,#17977,#17979,.T.); +#17975 = VERTEX_POINT('',#17976); +#17976 = CARTESIAN_POINT('',(21.449999999885,-62.6000000001,11.5)); +#17977 = VERTEX_POINT('',#17978); +#17978 = CARTESIAN_POINT('',(1.449999999885,-62.60000000007,31.5)); +#17979 = SURFACE_CURVE('',#17980,(#17984,#17991),.PCURVE_S1.); +#17980 = LINE('',#17981,#17982); +#17981 = CARTESIAN_POINT('',(1.149999999885,-62.60000000007,31.8)); +#17982 = VECTOR('',#17983,1.); +#17983 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#17984 = PCURVE('',#3842,#17985); +#17985 = DEFINITIONAL_REPRESENTATION('',(#17986),#17990); +#17986 = LINE('',#17987,#17988); +#17987 = CARTESIAN_POINT('',(-13.65000000001,23.84999999999)); +#17988 = VECTOR('',#17989,1.); +#17989 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#17990 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17991 = PCURVE('',#7996,#17992); +#17992 = DEFINITIONAL_REPRESENTATION('',(#17993),#17997); +#17993 = LINE('',#17994,#17995); +#17994 = CARTESIAN_POINT('',(35.779603128055,2.)); +#17995 = VECTOR('',#17996,1.); +#17996 = DIRECTION('',(1.,-8.10752882526E-29)); +#17997 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#17998 = ORIENTED_EDGE('',*,*,#17999,.F.); +#17999 = EDGE_CURVE('',#18000,#17975,#18002,.T.); +#18000 = VERTEX_POINT('',#18001); +#18001 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18002 = SURFACE_CURVE('',#18003,(#18007,#18014),.PCURVE_S1.); +#18003 = LINE('',#18004,#18005); +#18004 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18005 = VECTOR('',#18006,1.); +#18006 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18007 = PCURVE('',#3842,#18008); +#18008 = DEFINITIONAL_REPRESENTATION('',(#18009),#18013); +#18009 = LINE('',#18010,#18011); +#18010 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18011 = VECTOR('',#18012,1.); +#18012 = DIRECTION('',(5.560352306441E-42,-1.)); +#18013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18014 = PCURVE('',#7970,#18015); +#18015 = DEFINITIONAL_REPRESENTATION('',(#18016),#18020); +#18016 = LINE('',#18017,#18018); +#18017 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18018 = VECTOR('',#18019,1.); +#18019 = DIRECTION('',(1.,2.343516320473E-42)); +#18020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18021 = ORIENTED_EDGE('',*,*,#18022,.T.); +#18022 = EDGE_CURVE('',#18000,#3827,#18023,.T.); +#18023 = SURFACE_CURVE('',#18024,(#18028,#18035),.PCURVE_S1.); +#18024 = LINE('',#18025,#18026); +#18025 = CARTESIAN_POINT('',(22.000000000023,-62.6000000001, + 19.324999999994)); +#18026 = VECTOR('',#18027,1.); +#18027 = DIRECTION('',(-6.625507528813E-29,-1.833155447161E-15,-1.)); +#18028 = PCURVE('',#3842,#18029); +#18029 = DEFINITIONAL_REPRESENTATION('',(#18030),#18034); +#18030 = LINE('',#18031,#18032); +#18031 = CARTESIAN_POINT('',(-1.175000000007,44.700000000128)); +#18032 = VECTOR('',#18033,1.); +#18033 = DIRECTION('',(1.,1.227204140679E-27)); +#18034 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18035 = PCURVE('',#3870,#18036); +#18036 = DEFINITIONAL_REPRESENTATION('',(#18037),#18041); +#18037 = LINE('',#18038,#18039); +#18038 = CARTESIAN_POINT('',(12.175000000007,2.)); +#18039 = VECTOR('',#18040,1.); +#18040 = DIRECTION('',(1.,-1.747694647186E-15)); +#18041 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18042 = ORIENTED_EDGE('',*,*,#3826,.F.); +#18043 = ORIENTED_EDGE('',*,*,#16610,.T.); +#18044 = ORIENTED_EDGE('',*,*,#18045,.F.); +#18045 = EDGE_CURVE('',#18046,#12740,#18048,.T.); +#18046 = VERTEX_POINT('',#18047); +#18047 = CARTESIAN_POINT('',(-23.55000000011,-62.60000000003,11.5)); +#18048 = SURFACE_CURVE('',#18049,(#18053,#18060),.PCURVE_S1.); +#18049 = LINE('',#18050,#18051); +#18050 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18051 = VECTOR('',#18052,1.); +#18052 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18053 = PCURVE('',#3842,#18054); +#18054 = DEFINITIONAL_REPRESENTATION('',(#18055),#18059); +#18055 = LINE('',#18056,#18057); +#18056 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18057 = VECTOR('',#18058,1.); +#18058 = DIRECTION('',(5.560352306441E-42,-1.)); +#18059 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18060 = PCURVE('',#7245,#18061); +#18061 = DEFINITIONAL_REPRESENTATION('',(#18062),#18066); +#18062 = LINE('',#18063,#18064); +#18063 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18064 = VECTOR('',#18065,1.); +#18065 = DIRECTION('',(1.,2.343516320473E-42)); +#18066 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18067 = ORIENTED_EDGE('',*,*,#18068,.F.); +#18068 = EDGE_CURVE('',#12689,#18046,#18069,.T.); +#18069 = SURFACE_CURVE('',#18070,(#18074,#18081),.PCURVE_S1.); +#18070 = LINE('',#18071,#18072); +#18071 = CARTESIAN_POINT('',(-43.85000000011,-62.6,31.8)); +#18072 = VECTOR('',#18073,1.); +#18073 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18074 = PCURVE('',#3842,#18075); +#18075 = DEFINITIONAL_REPRESENTATION('',(#18076),#18080); +#18076 = LINE('',#18077,#18078); +#18077 = CARTESIAN_POINT('',(-13.65000000001,-21.15000000001)); +#18078 = VECTOR('',#18079,1.); +#18079 = DIRECTION('',(0.707106781187,0.707106781187)); +#18080 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18081 = PCURVE('',#7217,#18082); +#18082 = DEFINITIONAL_REPRESENTATION('',(#18083),#18087); +#18083 = LINE('',#18084,#18085); +#18084 = CARTESIAN_POINT('',(-5.830541613256E-16,2.)); +#18085 = VECTOR('',#18086,1.); +#18086 = DIRECTION('',(1.,1.854674126415E-29)); +#18087 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18088 = ORIENTED_EDGE('',*,*,#16588,.T.); +#18089 = ORIENTED_EDGE('',*,*,#18090,.F.); +#18090 = EDGE_CURVE('',#18091,#12840,#18093,.T.); +#18091 = VERTEX_POINT('',#18092); +#18092 = CARTESIAN_POINT('',(-20.55000000011,-62.60000000004,11.5)); +#18093 = SURFACE_CURVE('',#18094,(#18098,#18105),.PCURVE_S1.); +#18094 = LINE('',#18095,#18096); +#18095 = CARTESIAN_POINT('',(-40.85000000011,-62.60000000001,31.8)); +#18096 = VECTOR('',#18097,1.); +#18097 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18098 = PCURVE('',#3842,#18099); +#18099 = DEFINITIONAL_REPRESENTATION('',(#18100),#18104); +#18100 = LINE('',#18101,#18102); +#18101 = CARTESIAN_POINT('',(-13.65000000001,-18.15000000001)); +#18102 = VECTOR('',#18103,1.); +#18103 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18105 = PCURVE('',#7159,#18106); +#18106 = DEFINITIONAL_REPRESENTATION('',(#18107),#18111); +#18107 = LINE('',#18108,#18109); +#18108 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18109 = VECTOR('',#18110,1.); +#18110 = DIRECTION('',(1.,-8.10752882526E-29)); +#18111 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18112 = ORIENTED_EDGE('',*,*,#18113,.F.); +#18113 = EDGE_CURVE('',#18114,#18091,#18116,.T.); +#18114 = VERTEX_POINT('',#18115); +#18115 = CARTESIAN_POINT('',(-17.55000000011,-62.60000000004,11.5)); +#18116 = SURFACE_CURVE('',#18117,(#18121,#18128),.PCURVE_S1.); +#18117 = LINE('',#18118,#18119); +#18118 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18119 = VECTOR('',#18120,1.); +#18120 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18121 = PCURVE('',#3842,#18122); +#18122 = DEFINITIONAL_REPRESENTATION('',(#18123),#18127); +#18123 = LINE('',#18124,#18125); +#18124 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18125 = VECTOR('',#18126,1.); +#18126 = DIRECTION('',(5.560352306441E-42,-1.)); +#18127 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18128 = PCURVE('',#7131,#18129); +#18129 = DEFINITIONAL_REPRESENTATION('',(#18130),#18134); +#18130 = LINE('',#18131,#18132); +#18131 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18132 = VECTOR('',#18133,1.); +#18133 = DIRECTION('',(1.,2.343516320473E-42)); +#18134 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18135 = ORIENTED_EDGE('',*,*,#18136,.F.); +#18136 = EDGE_CURVE('',#12789,#18114,#18137,.T.); +#18137 = SURFACE_CURVE('',#18138,(#18142,#18149),.PCURVE_S1.); +#18138 = LINE('',#18139,#18140); +#18139 = CARTESIAN_POINT('',(-37.85000000011,-62.60000000001,31.8)); +#18140 = VECTOR('',#18141,1.); +#18141 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18142 = PCURVE('',#3842,#18143); +#18143 = DEFINITIONAL_REPRESENTATION('',(#18144),#18148); +#18144 = LINE('',#18145,#18146); +#18145 = CARTESIAN_POINT('',(-13.65000000001,-15.15000000001)); +#18146 = VECTOR('',#18147,1.); +#18147 = DIRECTION('',(0.707106781187,0.707106781187)); +#18148 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18149 = PCURVE('',#7103,#18150); +#18150 = DEFINITIONAL_REPRESENTATION('',(#18151),#18155); +#18151 = LINE('',#18152,#18153); +#18152 = CARTESIAN_POINT('',(-4.194266816291E-15,2.)); +#18153 = VECTOR('',#18154,1.); +#18154 = DIRECTION('',(1.,1.854674126415E-29)); +#18155 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18156 = ORIENTED_EDGE('',*,*,#16566,.T.); +#18157 = ORIENTED_EDGE('',*,*,#18158,.F.); +#18158 = EDGE_CURVE('',#18159,#12940,#18161,.T.); +#18159 = VERTEX_POINT('',#18160); +#18160 = CARTESIAN_POINT('',(-14.55000000011,-62.60000000005,11.5)); +#18161 = SURFACE_CURVE('',#18162,(#18166,#18173),.PCURVE_S1.); +#18162 = LINE('',#18163,#18164); +#18163 = CARTESIAN_POINT('',(-34.85000000011,-62.60000000002,31.8)); +#18164 = VECTOR('',#18165,1.); +#18165 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18166 = PCURVE('',#3842,#18167); +#18167 = DEFINITIONAL_REPRESENTATION('',(#18168),#18172); +#18168 = LINE('',#18169,#18170); +#18169 = CARTESIAN_POINT('',(-13.65000000001,-12.15000000001)); +#18170 = VECTOR('',#18171,1.); +#18171 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18172 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18173 = PCURVE('',#7359,#18174); +#18174 = DEFINITIONAL_REPRESENTATION('',(#18175),#18179); +#18175 = LINE('',#18176,#18177); +#18176 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18177 = VECTOR('',#18178,1.); +#18178 = DIRECTION('',(1.,-8.10752882526E-29)); +#18179 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18180 = ORIENTED_EDGE('',*,*,#18181,.F.); +#18181 = EDGE_CURVE('',#18182,#18159,#18184,.T.); +#18182 = VERTEX_POINT('',#18183); +#18183 = CARTESIAN_POINT('',(-11.55000000011,-62.60000000005,11.5)); +#18184 = SURFACE_CURVE('',#18185,(#18189,#18196),.PCURVE_S1.); +#18185 = LINE('',#18186,#18187); +#18186 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18187 = VECTOR('',#18188,1.); +#18188 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18189 = PCURVE('',#3842,#18190); +#18190 = DEFINITIONAL_REPRESENTATION('',(#18191),#18195); +#18191 = LINE('',#18192,#18193); +#18192 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18193 = VECTOR('',#18194,1.); +#18194 = DIRECTION('',(5.560352306441E-42,-1.)); +#18195 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18196 = PCURVE('',#7331,#18197); +#18197 = DEFINITIONAL_REPRESENTATION('',(#18198),#18202); +#18198 = LINE('',#18199,#18200); +#18199 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18200 = VECTOR('',#18201,1.); +#18201 = DIRECTION('',(1.,2.343516320473E-42)); +#18202 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18203 = ORIENTED_EDGE('',*,*,#18204,.F.); +#18204 = EDGE_CURVE('',#12889,#18182,#18205,.T.); +#18205 = SURFACE_CURVE('',#18206,(#18210,#18217),.PCURVE_S1.); +#18206 = LINE('',#18207,#18208); +#18207 = CARTESIAN_POINT('',(-31.85000000011,-62.60000000002,31.8)); +#18208 = VECTOR('',#18209,1.); +#18209 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18210 = PCURVE('',#3842,#18211); +#18211 = DEFINITIONAL_REPRESENTATION('',(#18212),#18216); +#18212 = LINE('',#18213,#18214); +#18213 = CARTESIAN_POINT('',(-13.65000000001,-9.15000000001)); +#18214 = VECTOR('',#18215,1.); +#18215 = DIRECTION('',(0.707106781187,0.707106781187)); +#18216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18217 = PCURVE('',#7303,#18218); +#18218 = DEFINITIONAL_REPRESENTATION('',(#18219),#18223); +#18219 = LINE('',#18220,#18221); +#18220 = CARTESIAN_POINT('',(1.715899062181E-14,2.)); +#18221 = VECTOR('',#18222,1.); +#18222 = DIRECTION('',(1.,1.854674126415E-29)); +#18223 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18224 = ORIENTED_EDGE('',*,*,#16544,.T.); +#18225 = ORIENTED_EDGE('',*,*,#18226,.F.); +#18226 = EDGE_CURVE('',#18227,#13063,#18229,.T.); +#18227 = VERTEX_POINT('',#18228); +#18228 = CARTESIAN_POINT('',(-8.550000000116,-62.60000000005,11.5)); +#18229 = SURFACE_CURVE('',#18230,(#18234,#18241),.PCURVE_S1.); +#18230 = LINE('',#18231,#18232); +#18231 = CARTESIAN_POINT('',(-28.85000000011,-62.60000000003,31.8)); +#18232 = VECTOR('',#18233,1.); +#18233 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18234 = PCURVE('',#3842,#18235); +#18235 = DEFINITIONAL_REPRESENTATION('',(#18236),#18240); +#18236 = LINE('',#18237,#18238); +#18237 = CARTESIAN_POINT('',(-13.65000000001,-6.15000000001)); +#18238 = VECTOR('',#18239,1.); +#18239 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18240 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18241 = PCURVE('',#7582,#18242); +#18242 = DEFINITIONAL_REPRESENTATION('',(#18243),#18247); +#18243 = LINE('',#18244,#18245); +#18244 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18245 = VECTOR('',#18246,1.); +#18246 = DIRECTION('',(1.,-8.10752882526E-29)); +#18247 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18248 = ORIENTED_EDGE('',*,*,#18249,.F.); +#18249 = EDGE_CURVE('',#18250,#18227,#18252,.T.); +#18250 = VERTEX_POINT('',#18251); +#18251 = CARTESIAN_POINT('',(-5.550000000115,-62.60000000006,11.5)); +#18252 = SURFACE_CURVE('',#18253,(#18257,#18264),.PCURVE_S1.); +#18253 = LINE('',#18254,#18255); +#18254 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18255 = VECTOR('',#18256,1.); +#18256 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18257 = PCURVE('',#3842,#18258); +#18258 = DEFINITIONAL_REPRESENTATION('',(#18259),#18263); +#18259 = LINE('',#18260,#18261); +#18260 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18261 = VECTOR('',#18262,1.); +#18262 = DIRECTION('',(5.560352306441E-42,-1.)); +#18263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18264 = PCURVE('',#7554,#18265); +#18265 = DEFINITIONAL_REPRESENTATION('',(#18266),#18270); +#18266 = LINE('',#18267,#18268); +#18267 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18268 = VECTOR('',#18269,1.); +#18269 = DIRECTION('',(1.,2.343516320473E-42)); +#18270 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18271 = ORIENTED_EDGE('',*,*,#18272,.F.); +#18272 = EDGE_CURVE('',#12989,#18250,#18273,.T.); +#18273 = SURFACE_CURVE('',#18274,(#18278,#18285),.PCURVE_S1.); +#18274 = LINE('',#18275,#18276); +#18275 = CARTESIAN_POINT('',(-25.85000000011,-62.60000000003,31.8)); +#18276 = VECTOR('',#18277,1.); +#18277 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18278 = PCURVE('',#3842,#18279); +#18279 = DEFINITIONAL_REPRESENTATION('',(#18280),#18284); +#18280 = LINE('',#18281,#18282); +#18281 = CARTESIAN_POINT('',(-13.65000000001,-3.150000000011)); +#18282 = VECTOR('',#18283,1.); +#18283 = DIRECTION('',(0.707106781187,0.707106781187)); +#18284 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18285 = PCURVE('',#7526,#18286); +#18286 = DEFINITIONAL_REPRESENTATION('',(#18287),#18291); +#18287 = LINE('',#18288,#18289); +#18288 = CARTESIAN_POINT('',(1.715899062179E-14,2.)); +#18289 = VECTOR('',#18290,1.); +#18290 = DIRECTION('',(1.,1.854674126415E-29)); +#18291 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18292 = ORIENTED_EDGE('',*,*,#16522,.T.); +#18293 = ORIENTED_EDGE('',*,*,#12578,.T.); +#18294 = ORIENTED_EDGE('',*,*,#18295,.T.); +#18295 = EDGE_CURVE('',#12556,#18296,#18298,.T.); +#18296 = VERTEX_POINT('',#18297); +#18297 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,31.5)); +#18298 = SURFACE_CURVE('',#18299,(#18303,#18310),.PCURVE_S1.); +#18299 = LINE('',#18300,#18301); +#18300 = CARTESIAN_POINT('',(22.000000000023,-62.6000000001, + 19.324999999994)); +#18301 = VECTOR('',#18302,1.); +#18302 = DIRECTION('',(-6.625507528813E-29,-1.833155447161E-15,-1.)); +#18303 = PCURVE('',#3842,#18304); +#18304 = DEFINITIONAL_REPRESENTATION('',(#18305),#18309); +#18305 = LINE('',#18306,#18307); +#18306 = CARTESIAN_POINT('',(-1.175000000007,44.700000000128)); +#18307 = VECTOR('',#18308,1.); +#18308 = DIRECTION('',(1.,1.227204140679E-27)); +#18309 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18310 = PCURVE('',#3870,#18311); +#18311 = DEFINITIONAL_REPRESENTATION('',(#18312),#18316); +#18312 = LINE('',#18313,#18314); +#18313 = CARTESIAN_POINT('',(12.175000000007,2.)); +#18314 = VECTOR('',#18315,1.); +#18315 = DIRECTION('',(1.,-1.747694647186E-15)); +#18316 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18317 = ORIENTED_EDGE('',*,*,#18318,.F.); +#18318 = EDGE_CURVE('',#18319,#18296,#18321,.T.); +#18319 = VERTEX_POINT('',#18320); +#18320 = CARTESIAN_POINT('',(19.449999999885,-62.60000000009,31.5)); +#18321 = SURFACE_CURVE('',#18322,(#18326,#18333),.PCURVE_S1.); +#18322 = LINE('',#18323,#18324); +#18323 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18324 = VECTOR('',#18325,1.); +#18325 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18326 = PCURVE('',#3842,#18327); +#18327 = DEFINITIONAL_REPRESENTATION('',(#18328),#18332); +#18328 = LINE('',#18329,#18330); +#18329 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18330 = VECTOR('',#18331,1.); +#18331 = DIRECTION('',(-5.560352306441E-42,1.)); +#18332 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18333 = PCURVE('',#7022,#18334); +#18334 = DEFINITIONAL_REPRESENTATION('',(#18335),#18339); +#18335 = LINE('',#18336,#18337); +#18336 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18337 = VECTOR('',#18338,1.); +#18338 = DIRECTION('',(1.,-2.343516320473E-42)); +#18339 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18340 = ORIENTED_EDGE('',*,*,#18341,.F.); +#18341 = EDGE_CURVE('',#18342,#18319,#18344,.T.); +#18342 = VERTEX_POINT('',#18343); +#18343 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 28.949999999952)); +#18344 = SURFACE_CURVE('',#18345,(#18349,#18356),.PCURVE_S1.); +#18345 = LINE('',#18346,#18347); +#18346 = CARTESIAN_POINT('',(19.149999999885,-62.60000000009,31.8)); +#18347 = VECTOR('',#18348,1.); +#18348 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18349 = PCURVE('',#3842,#18350); +#18350 = DEFINITIONAL_REPRESENTATION('',(#18351),#18355); +#18351 = LINE('',#18352,#18353); +#18352 = CARTESIAN_POINT('',(-13.65000000001,41.84999999999)); +#18353 = VECTOR('',#18354,1.); +#18354 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18355 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18356 = PCURVE('',#7071,#18357); +#18357 = DEFINITIONAL_REPRESENTATION('',(#18358),#18362); +#18358 = LINE('',#18359,#18360); +#18359 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18360 = VECTOR('',#18361,1.); +#18361 = DIRECTION('',(1.,-8.10752882526E-29)); +#18362 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18363 = ORIENTED_EDGE('',*,*,#18364,.T.); +#18364 = EDGE_CURVE('',#18342,#18365,#18367,.T.); +#18365 = VERTEX_POINT('',#18366); +#18366 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 25.949999999952)); +#18367 = SURFACE_CURVE('',#18368,(#18372,#18379),.PCURVE_S1.); +#18368 = LINE('',#18369,#18370); +#18369 = CARTESIAN_POINT('',(22.000000000023,-62.6000000001, + 19.324999999994)); +#18370 = VECTOR('',#18371,1.); +#18371 = DIRECTION('',(-6.625507528813E-29,-1.833155447161E-15,-1.)); +#18372 = PCURVE('',#3842,#18373); +#18373 = DEFINITIONAL_REPRESENTATION('',(#18374),#18378); +#18374 = LINE('',#18375,#18376); +#18375 = CARTESIAN_POINT('',(-1.175000000007,44.700000000128)); +#18376 = VECTOR('',#18377,1.); +#18377 = DIRECTION('',(1.,1.227204140679E-27)); +#18378 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18379 = PCURVE('',#3870,#18380); +#18380 = DEFINITIONAL_REPRESENTATION('',(#18381),#18385); +#18381 = LINE('',#18382,#18383); +#18382 = CARTESIAN_POINT('',(12.175000000007,2.)); +#18383 = VECTOR('',#18384,1.); +#18384 = DIRECTION('',(1.,-1.747694647186E-15)); +#18385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18386 = ORIENTED_EDGE('',*,*,#18387,.F.); +#18387 = EDGE_CURVE('',#18388,#18365,#18390,.T.); +#18388 = VERTEX_POINT('',#18389); +#18389 = CARTESIAN_POINT('',(16.449999999885,-62.60000000009,31.5)); +#18390 = SURFACE_CURVE('',#18391,(#18395,#18402),.PCURVE_S1.); +#18391 = LINE('',#18392,#18393); +#18392 = CARTESIAN_POINT('',(16.149999999885,-62.60000000009,31.8)); +#18393 = VECTOR('',#18394,1.); +#18394 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18395 = PCURVE('',#3842,#18396); +#18396 = DEFINITIONAL_REPRESENTATION('',(#18397),#18401); +#18397 = LINE('',#18398,#18399); +#18398 = CARTESIAN_POINT('',(-13.65000000001,38.84999999999)); +#18399 = VECTOR('',#18400,1.); +#18400 = DIRECTION('',(0.707106781187,0.707106781187)); +#18401 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18402 = PCURVE('',#7445,#18403); +#18403 = DEFINITIONAL_REPRESENTATION('',(#18404),#18408); +#18404 = LINE('',#18405,#18406); +#18405 = CARTESIAN_POINT('',(1.464684268791E-14,2.)); +#18406 = VECTOR('',#18407,1.); +#18407 = DIRECTION('',(1.,1.854674126415E-29)); +#18408 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18409 = ORIENTED_EDGE('',*,*,#18410,.F.); +#18410 = EDGE_CURVE('',#18411,#18388,#18413,.T.); +#18411 = VERTEX_POINT('',#18412); +#18412 = CARTESIAN_POINT('',(13.449999999885,-62.60000000009,31.5)); +#18413 = SURFACE_CURVE('',#18414,(#18418,#18425),.PCURVE_S1.); +#18414 = LINE('',#18415,#18416); +#18415 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18416 = VECTOR('',#18417,1.); +#18417 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18418 = PCURVE('',#3842,#18419); +#18419 = DEFINITIONAL_REPRESENTATION('',(#18420),#18424); +#18420 = LINE('',#18421,#18422); +#18421 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18422 = VECTOR('',#18423,1.); +#18423 = DIRECTION('',(-5.560352306441E-42,1.)); +#18424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18425 = PCURVE('',#7417,#18426); +#18426 = DEFINITIONAL_REPRESENTATION('',(#18427),#18431); +#18427 = LINE('',#18428,#18429); +#18428 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18429 = VECTOR('',#18430,1.); +#18430 = DIRECTION('',(1.,-2.343516320473E-42)); +#18431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18432 = ORIENTED_EDGE('',*,*,#18433,.F.); +#18433 = EDGE_CURVE('',#18434,#18411,#18436,.T.); +#18434 = VERTEX_POINT('',#18435); +#18435 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 22.949999999952)); +#18436 = SURFACE_CURVE('',#18437,(#18441,#18448),.PCURVE_S1.); +#18437 = LINE('',#18438,#18439); +#18438 = CARTESIAN_POINT('',(13.149999999885,-62.60000000009,31.8)); +#18439 = VECTOR('',#18440,1.); +#18440 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18441 = PCURVE('',#3842,#18442); +#18442 = DEFINITIONAL_REPRESENTATION('',(#18443),#18447); +#18443 = LINE('',#18444,#18445); +#18444 = CARTESIAN_POINT('',(-13.65000000001,35.84999999999)); +#18445 = VECTOR('',#18446,1.); +#18446 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18447 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18448 = PCURVE('',#7494,#18449); +#18449 = DEFINITIONAL_REPRESENTATION('',(#18450),#18454); +#18450 = LINE('',#18451,#18452); +#18451 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18452 = VECTOR('',#18453,1.); +#18453 = DIRECTION('',(1.,-8.10752882526E-29)); +#18454 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18455 = ORIENTED_EDGE('',*,*,#18456,.T.); +#18456 = EDGE_CURVE('',#18434,#18457,#18459,.T.); +#18457 = VERTEX_POINT('',#18458); +#18458 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 19.949999999952)); +#18459 = SURFACE_CURVE('',#18460,(#18464,#18471),.PCURVE_S1.); +#18460 = LINE('',#18461,#18462); +#18461 = CARTESIAN_POINT('',(22.000000000023,-62.6000000001, + 19.324999999994)); +#18462 = VECTOR('',#18463,1.); +#18463 = DIRECTION('',(-6.625507528813E-29,-1.833155447161E-15,-1.)); +#18464 = PCURVE('',#3842,#18465); +#18465 = DEFINITIONAL_REPRESENTATION('',(#18466),#18470); +#18466 = LINE('',#18467,#18468); +#18467 = CARTESIAN_POINT('',(-1.175000000007,44.700000000128)); +#18468 = VECTOR('',#18469,1.); +#18469 = DIRECTION('',(1.,1.227204140679E-27)); +#18470 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18471 = PCURVE('',#3870,#18472); +#18472 = DEFINITIONAL_REPRESENTATION('',(#18473),#18477); +#18473 = LINE('',#18474,#18475); +#18474 = CARTESIAN_POINT('',(12.175000000007,2.)); +#18475 = VECTOR('',#18476,1.); +#18476 = DIRECTION('',(1.,-1.747694647186E-15)); +#18477 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18478 = ORIENTED_EDGE('',*,*,#18479,.F.); +#18479 = EDGE_CURVE('',#18480,#18457,#18482,.T.); +#18480 = VERTEX_POINT('',#18481); +#18481 = CARTESIAN_POINT('',(10.449999999885,-62.60000000008,31.5)); +#18482 = SURFACE_CURVE('',#18483,(#18487,#18494),.PCURVE_S1.); +#18483 = LINE('',#18484,#18485); +#18484 = CARTESIAN_POINT('',(10.149999999885,-62.60000000008,31.8)); +#18485 = VECTOR('',#18486,1.); +#18486 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18487 = PCURVE('',#3842,#18488); +#18488 = DEFINITIONAL_REPRESENTATION('',(#18489),#18493); +#18489 = LINE('',#18490,#18491); +#18490 = CARTESIAN_POINT('',(-13.65000000001,32.84999999999)); +#18491 = VECTOR('',#18492,1.); +#18492 = DIRECTION('',(0.707106781187,0.707106781187)); +#18493 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18494 = PCURVE('',#7696,#18495); +#18495 = DEFINITIONAL_REPRESENTATION('',(#18496),#18500); +#18496 = LINE('',#18497,#18498); +#18497 = CARTESIAN_POINT('',(1.464684268791E-14,2.)); +#18498 = VECTOR('',#18499,1.); +#18499 = DIRECTION('',(1.,1.854674126415E-29)); +#18500 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18501 = ORIENTED_EDGE('',*,*,#18502,.F.); +#18502 = EDGE_CURVE('',#18503,#18480,#18505,.T.); +#18503 = VERTEX_POINT('',#18504); +#18504 = CARTESIAN_POINT('',(7.449999999885,-62.60000000008,31.5)); +#18505 = SURFACE_CURVE('',#18506,(#18510,#18517),.PCURVE_S1.); +#18506 = LINE('',#18507,#18508); +#18507 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18508 = VECTOR('',#18509,1.); +#18509 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18510 = PCURVE('',#3842,#18511); +#18511 = DEFINITIONAL_REPRESENTATION('',(#18512),#18516); +#18512 = LINE('',#18513,#18514); +#18513 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18514 = VECTOR('',#18515,1.); +#18515 = DIRECTION('',(-5.560352306441E-42,1.)); +#18516 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18517 = PCURVE('',#7668,#18518); +#18518 = DEFINITIONAL_REPRESENTATION('',(#18519),#18523); +#18519 = LINE('',#18520,#18521); +#18520 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18521 = VECTOR('',#18522,1.); +#18522 = DIRECTION('',(1.,-2.343516320473E-42)); +#18523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18524 = ORIENTED_EDGE('',*,*,#18525,.F.); +#18525 = EDGE_CURVE('',#18526,#18503,#18528,.T.); +#18526 = VERTEX_POINT('',#18527); +#18527 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 16.949999999952)); +#18528 = SURFACE_CURVE('',#18529,(#18533,#18540),.PCURVE_S1.); +#18529 = LINE('',#18530,#18531); +#18530 = CARTESIAN_POINT('',(7.149999999885,-62.60000000008,31.8)); +#18531 = VECTOR('',#18532,1.); +#18532 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18533 = PCURVE('',#3842,#18534); +#18534 = DEFINITIONAL_REPRESENTATION('',(#18535),#18539); +#18535 = LINE('',#18536,#18537); +#18536 = CARTESIAN_POINT('',(-13.65000000001,29.84999999999)); +#18537 = VECTOR('',#18538,1.); +#18538 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18539 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18540 = PCURVE('',#7745,#18541); +#18541 = DEFINITIONAL_REPRESENTATION('',(#18542),#18546); +#18542 = LINE('',#18543,#18544); +#18543 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18544 = VECTOR('',#18545,1.); +#18545 = DIRECTION('',(1.,-8.10752882526E-29)); +#18546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18547 = ORIENTED_EDGE('',*,*,#18548,.T.); +#18548 = EDGE_CURVE('',#18526,#18549,#18551,.T.); +#18549 = VERTEX_POINT('',#18550); +#18550 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001, + 13.949999999952)); +#18551 = SURFACE_CURVE('',#18552,(#18556,#18563),.PCURVE_S1.); +#18552 = LINE('',#18553,#18554); +#18553 = CARTESIAN_POINT('',(22.000000000023,-62.6000000001, + 19.324999999994)); +#18554 = VECTOR('',#18555,1.); +#18555 = DIRECTION('',(-6.625507528813E-29,-1.833155447161E-15,-1.)); +#18556 = PCURVE('',#3842,#18557); +#18557 = DEFINITIONAL_REPRESENTATION('',(#18558),#18562); +#18558 = LINE('',#18559,#18560); +#18559 = CARTESIAN_POINT('',(-1.175000000007,44.700000000128)); +#18560 = VECTOR('',#18561,1.); +#18561 = DIRECTION('',(1.,1.227204140679E-27)); +#18562 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18563 = PCURVE('',#3870,#18564); +#18564 = DEFINITIONAL_REPRESENTATION('',(#18565),#18569); +#18565 = LINE('',#18566,#18567); +#18566 = CARTESIAN_POINT('',(12.175000000007,2.)); +#18567 = VECTOR('',#18568,1.); +#18568 = DIRECTION('',(1.,-1.747694647186E-15)); +#18569 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18570 = ORIENTED_EDGE('',*,*,#18571,.F.); +#18571 = EDGE_CURVE('',#18572,#18549,#18574,.T.); +#18572 = VERTEX_POINT('',#18573); +#18573 = CARTESIAN_POINT('',(4.449999999885,-62.60000000007,31.5)); +#18574 = SURFACE_CURVE('',#18575,(#18579,#18586),.PCURVE_S1.); +#18575 = LINE('',#18576,#18577); +#18576 = CARTESIAN_POINT('',(4.149999999885,-62.60000000007,31.8)); +#18577 = VECTOR('',#18578,1.); +#18578 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18579 = PCURVE('',#3842,#18580); +#18580 = DEFINITIONAL_REPRESENTATION('',(#18581),#18585); +#18581 = LINE('',#18582,#18583); +#18582 = CARTESIAN_POINT('',(-13.65000000001,26.84999999999)); +#18583 = VECTOR('',#18584,1.); +#18584 = DIRECTION('',(0.707106781187,0.707106781187)); +#18585 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18586 = PCURVE('',#7919,#18587); +#18587 = DEFINITIONAL_REPRESENTATION('',(#18588),#18592); +#18588 = LINE('',#18589,#18590); +#18589 = CARTESIAN_POINT('',(1.46468426879E-14,2.)); +#18590 = VECTOR('',#18591,1.); +#18591 = DIRECTION('',(1.,1.854674126415E-29)); +#18592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18593 = ORIENTED_EDGE('',*,*,#18594,.F.); +#18594 = EDGE_CURVE('',#17977,#18572,#18595,.T.); +#18595 = SURFACE_CURVE('',#18596,(#18600,#18607),.PCURVE_S1.); +#18596 = LINE('',#18597,#18598); +#18597 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18598 = VECTOR('',#18599,1.); +#18599 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18600 = PCURVE('',#3842,#18601); +#18601 = DEFINITIONAL_REPRESENTATION('',(#18602),#18606); +#18602 = LINE('',#18603,#18604); +#18603 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18604 = VECTOR('',#18605,1.); +#18605 = DIRECTION('',(-5.560352306441E-42,1.)); +#18606 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18607 = PCURVE('',#7891,#18608); +#18608 = DEFINITIONAL_REPRESENTATION('',(#18609),#18613); +#18609 = LINE('',#18610,#18611); +#18610 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18611 = VECTOR('',#18612,1.); +#18612 = DIRECTION('',(1.,-2.343516320473E-42)); +#18613 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18614 = FACE_BOUND('',#18615,.T.); +#18615 = EDGE_LOOP('',(#18616,#18641,#18664,#18687)); +#18616 = ORIENTED_EDGE('',*,*,#18617,.F.); +#18617 = EDGE_CURVE('',#18618,#18620,#18622,.T.); +#18618 = VERTEX_POINT('',#18619); +#18619 = CARTESIAN_POINT('',(15.449999999884,-62.60000000009,11.5)); +#18620 = VERTEX_POINT('',#18621); +#18621 = CARTESIAN_POINT('',(-4.550000000115,-62.60000000006,31.5)); +#18622 = SURFACE_CURVE('',#18623,(#18627,#18634),.PCURVE_S1.); +#18623 = LINE('',#18624,#18625); +#18624 = CARTESIAN_POINT('',(-4.850000000115,-62.60000000006,31.8)); +#18625 = VECTOR('',#18626,1.); +#18626 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18627 = PCURVE('',#3842,#18628); +#18628 = DEFINITIONAL_REPRESENTATION('',(#18629),#18633); +#18629 = LINE('',#18630,#18631); +#18630 = CARTESIAN_POINT('',(-13.65000000001,17.84999999999)); +#18631 = VECTOR('',#18632,1.); +#18632 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18633 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18634 = PCURVE('',#8224,#18635); +#18635 = DEFINITIONAL_REPRESENTATION('',(#18636),#18640); +#18636 = LINE('',#18637,#18638); +#18637 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18638 = VECTOR('',#18639,1.); +#18639 = DIRECTION('',(1.,-8.10752882526E-29)); +#18640 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18641 = ORIENTED_EDGE('',*,*,#18642,.F.); +#18642 = EDGE_CURVE('',#18643,#18618,#18645,.T.); +#18643 = VERTEX_POINT('',#18644); +#18644 = CARTESIAN_POINT('',(18.449999999885,-62.60000000009,11.5)); +#18645 = SURFACE_CURVE('',#18646,(#18650,#18657),.PCURVE_S1.); +#18646 = LINE('',#18647,#18648); +#18647 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18648 = VECTOR('',#18649,1.); +#18649 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18650 = PCURVE('',#3842,#18651); +#18651 = DEFINITIONAL_REPRESENTATION('',(#18652),#18656); +#18652 = LINE('',#18653,#18654); +#18653 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18654 = VECTOR('',#18655,1.); +#18655 = DIRECTION('',(5.560352306441E-42,-1.)); +#18656 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18657 = PCURVE('',#8198,#18658); +#18658 = DEFINITIONAL_REPRESENTATION('',(#18659),#18663); +#18659 = LINE('',#18660,#18661); +#18660 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18661 = VECTOR('',#18662,1.); +#18662 = DIRECTION('',(1.,2.343516320473E-42)); +#18663 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18664 = ORIENTED_EDGE('',*,*,#18665,.F.); +#18665 = EDGE_CURVE('',#18666,#18643,#18668,.T.); +#18666 = VERTEX_POINT('',#18667); +#18667 = CARTESIAN_POINT('',(-1.550000000115,-62.60000000006,31.5)); +#18668 = SURFACE_CURVE('',#18669,(#18673,#18680),.PCURVE_S1.); +#18669 = LINE('',#18670,#18671); +#18670 = CARTESIAN_POINT('',(-1.850000000115,-62.60000000006,31.8)); +#18671 = VECTOR('',#18672,1.); +#18672 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18673 = PCURVE('',#3842,#18674); +#18674 = DEFINITIONAL_REPRESENTATION('',(#18675),#18679); +#18675 = LINE('',#18676,#18677); +#18676 = CARTESIAN_POINT('',(-13.65000000001,20.84999999999)); +#18677 = VECTOR('',#18678,1.); +#18678 = DIRECTION('',(0.707106781187,0.707106781187)); +#18679 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18680 = PCURVE('',#8170,#18681); +#18681 = DEFINITIONAL_REPRESENTATION('',(#18682),#18686); +#18682 = LINE('',#18683,#18684); +#18683 = CARTESIAN_POINT('',(1.464684268791E-14,2.)); +#18684 = VECTOR('',#18685,1.); +#18685 = DIRECTION('',(1.,1.854674126415E-29)); +#18686 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18687 = ORIENTED_EDGE('',*,*,#18688,.F.); +#18688 = EDGE_CURVE('',#18620,#18666,#18689,.T.); +#18689 = SURFACE_CURVE('',#18690,(#18694,#18701),.PCURVE_S1.); +#18690 = LINE('',#18691,#18692); +#18691 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18692 = VECTOR('',#18693,1.); +#18693 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18694 = PCURVE('',#3842,#18695); +#18695 = DEFINITIONAL_REPRESENTATION('',(#18696),#18700); +#18696 = LINE('',#18697,#18698); +#18697 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18698 = VECTOR('',#18699,1.); +#18699 = DIRECTION('',(-5.560352306441E-42,1.)); +#18700 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18701 = PCURVE('',#8142,#18702); +#18702 = DEFINITIONAL_REPRESENTATION('',(#18703),#18707); +#18703 = LINE('',#18704,#18705); +#18704 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18705 = VECTOR('',#18706,1.); +#18706 = DIRECTION('',(1.,-2.343516320473E-42)); +#18707 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18708 = FACE_BOUND('',#18709,.T.); +#18709 = EDGE_LOOP('',(#18710,#18735,#18758,#18781)); +#18710 = ORIENTED_EDGE('',*,*,#18711,.F.); +#18711 = EDGE_CURVE('',#18712,#18714,#18716,.T.); +#18712 = VERTEX_POINT('',#18713); +#18713 = CARTESIAN_POINT('',(-10.55000000011,-62.60000000005,31.5)); +#18714 = VERTEX_POINT('',#18715); +#18715 = CARTESIAN_POINT('',(-7.550000000115,-62.60000000006,31.5)); +#18716 = SURFACE_CURVE('',#18717,(#18721,#18728),.PCURVE_S1.); +#18717 = LINE('',#18718,#18719); +#18718 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18719 = VECTOR('',#18720,1.); +#18720 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18721 = PCURVE('',#3842,#18722); +#18722 = DEFINITIONAL_REPRESENTATION('',(#18723),#18727); +#18723 = LINE('',#18724,#18725); +#18724 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18725 = VECTOR('',#18726,1.); +#18726 = DIRECTION('',(-5.560352306441E-42,1.)); +#18727 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18728 = PCURVE('',#8338,#18729); +#18729 = DEFINITIONAL_REPRESENTATION('',(#18730),#18734); +#18730 = LINE('',#18731,#18732); +#18731 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18732 = VECTOR('',#18733,1.); +#18733 = DIRECTION('',(1.,-2.343516320473E-42)); +#18734 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18735 = ORIENTED_EDGE('',*,*,#18736,.F.); +#18736 = EDGE_CURVE('',#18737,#18712,#18739,.T.); +#18737 = VERTEX_POINT('',#18738); +#18738 = CARTESIAN_POINT('',(9.449999999884,-62.60000000008,11.5)); +#18739 = SURFACE_CURVE('',#18740,(#18744,#18751),.PCURVE_S1.); +#18740 = LINE('',#18741,#18742); +#18741 = CARTESIAN_POINT('',(-10.85000000011,-62.60000000005,31.8)); +#18742 = VECTOR('',#18743,1.); +#18743 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18744 = PCURVE('',#3842,#18745); +#18745 = DEFINITIONAL_REPRESENTATION('',(#18746),#18750); +#18746 = LINE('',#18747,#18748); +#18747 = CARTESIAN_POINT('',(-13.65000000001,11.849999999989)); +#18748 = VECTOR('',#18749,1.); +#18749 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18750 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18751 = PCURVE('',#8312,#18752); +#18752 = DEFINITIONAL_REPRESENTATION('',(#18753),#18757); +#18753 = LINE('',#18754,#18755); +#18754 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18755 = VECTOR('',#18756,1.); +#18756 = DIRECTION('',(1.,-8.10752882526E-29)); +#18757 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18758 = ORIENTED_EDGE('',*,*,#18759,.F.); +#18759 = EDGE_CURVE('',#18760,#18737,#18762,.T.); +#18760 = VERTEX_POINT('',#18761); +#18761 = CARTESIAN_POINT('',(12.449999999885,-62.60000000008,11.5)); +#18762 = SURFACE_CURVE('',#18763,(#18767,#18774),.PCURVE_S1.); +#18763 = LINE('',#18764,#18765); +#18764 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18765 = VECTOR('',#18766,1.); +#18766 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18767 = PCURVE('',#3842,#18768); +#18768 = DEFINITIONAL_REPRESENTATION('',(#18769),#18773); +#18769 = LINE('',#18770,#18771); +#18770 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18771 = VECTOR('',#18772,1.); +#18772 = DIRECTION('',(5.560352306441E-42,-1.)); +#18773 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18774 = PCURVE('',#8284,#18775); +#18775 = DEFINITIONAL_REPRESENTATION('',(#18776),#18780); +#18776 = LINE('',#18777,#18778); +#18777 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18778 = VECTOR('',#18779,1.); +#18779 = DIRECTION('',(1.,2.343516320473E-42)); +#18780 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18781 = ORIENTED_EDGE('',*,*,#18782,.F.); +#18782 = EDGE_CURVE('',#18714,#18760,#18783,.T.); +#18783 = SURFACE_CURVE('',#18784,(#18788,#18795),.PCURVE_S1.); +#18784 = LINE('',#18785,#18786); +#18785 = CARTESIAN_POINT('',(-7.850000000115,-62.60000000006,31.8)); +#18786 = VECTOR('',#18787,1.); +#18787 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18788 = PCURVE('',#3842,#18789); +#18789 = DEFINITIONAL_REPRESENTATION('',(#18790),#18794); +#18790 = LINE('',#18791,#18792); +#18791 = CARTESIAN_POINT('',(-13.65000000001,14.84999999999)); +#18792 = VECTOR('',#18793,1.); +#18793 = DIRECTION('',(0.707106781187,0.707106781187)); +#18794 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18795 = PCURVE('',#8256,#18796); +#18796 = DEFINITIONAL_REPRESENTATION('',(#18797),#18801); +#18797 = LINE('',#18798,#18799); +#18798 = CARTESIAN_POINT('',(1.464684268791E-14,2.)); +#18799 = VECTOR('',#18800,1.); +#18800 = DIRECTION('',(1.,1.854674126415E-29)); +#18801 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18802 = FACE_BOUND('',#18803,.T.); +#18803 = EDGE_LOOP('',(#18804,#18829,#18852,#18875)); +#18804 = ORIENTED_EDGE('',*,*,#18805,.F.); +#18805 = EDGE_CURVE('',#18806,#18808,#18810,.T.); +#18806 = VERTEX_POINT('',#18807); +#18807 = CARTESIAN_POINT('',(-22.55000000011,-62.60000000003,31.5)); +#18808 = VERTEX_POINT('',#18809); +#18809 = CARTESIAN_POINT('',(-19.55000000011,-62.60000000004,31.5)); +#18810 = SURFACE_CURVE('',#18811,(#18815,#18822),.PCURVE_S1.); +#18811 = LINE('',#18812,#18813); +#18812 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18813 = VECTOR('',#18814,1.); +#18814 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18815 = PCURVE('',#3842,#18816); +#18816 = DEFINITIONAL_REPRESENTATION('',(#18817),#18821); +#18817 = LINE('',#18818,#18819); +#18818 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18819 = VECTOR('',#18820,1.); +#18820 = DIRECTION('',(-5.560352306441E-42,1.)); +#18821 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18822 = PCURVE('',#7859,#18823); +#18823 = DEFINITIONAL_REPRESENTATION('',(#18824),#18828); +#18824 = LINE('',#18825,#18826); +#18825 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18826 = VECTOR('',#18827,1.); +#18827 = DIRECTION('',(1.,-2.343516320473E-42)); +#18828 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18829 = ORIENTED_EDGE('',*,*,#18830,.F.); +#18830 = EDGE_CURVE('',#18831,#18806,#18833,.T.); +#18831 = VERTEX_POINT('',#18832); +#18832 = CARTESIAN_POINT('',(-2.550000000116,-62.60000000006,11.5)); +#18833 = SURFACE_CURVE('',#18834,(#18838,#18845),.PCURVE_S1.); +#18834 = LINE('',#18835,#18836); +#18835 = CARTESIAN_POINT('',(-22.85000000011,-62.60000000003,31.8)); +#18836 = VECTOR('',#18837,1.); +#18837 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18838 = PCURVE('',#3842,#18839); +#18839 = DEFINITIONAL_REPRESENTATION('',(#18840),#18844); +#18840 = LINE('',#18841,#18842); +#18841 = CARTESIAN_POINT('',(-13.65000000001,-0.150000000011)); +#18842 = VECTOR('',#18843,1.); +#18843 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18845 = PCURVE('',#7833,#18846); +#18846 = DEFINITIONAL_REPRESENTATION('',(#18847),#18851); +#18847 = LINE('',#18848,#18849); +#18848 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18849 = VECTOR('',#18850,1.); +#18850 = DIRECTION('',(1.,-8.10752882526E-29)); +#18851 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18852 = ORIENTED_EDGE('',*,*,#18853,.F.); +#18853 = EDGE_CURVE('',#18854,#18831,#18856,.T.); +#18854 = VERTEX_POINT('',#18855); +#18855 = CARTESIAN_POINT('',(0.449999999885,-62.60000000007,11.5)); +#18856 = SURFACE_CURVE('',#18857,(#18861,#18868),.PCURVE_S1.); +#18857 = LINE('',#18858,#18859); +#18858 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18859 = VECTOR('',#18860,1.); +#18860 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18861 = PCURVE('',#3842,#18862); +#18862 = DEFINITIONAL_REPRESENTATION('',(#18863),#18867); +#18863 = LINE('',#18864,#18865); +#18864 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18865 = VECTOR('',#18866,1.); +#18866 = DIRECTION('',(5.560352306441E-42,-1.)); +#18867 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18868 = PCURVE('',#7805,#18869); +#18869 = DEFINITIONAL_REPRESENTATION('',(#18870),#18874); +#18870 = LINE('',#18871,#18872); +#18871 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18872 = VECTOR('',#18873,1.); +#18873 = DIRECTION('',(1.,2.343516320473E-42)); +#18874 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18875 = ORIENTED_EDGE('',*,*,#18876,.F.); +#18876 = EDGE_CURVE('',#18808,#18854,#18877,.T.); +#18877 = SURFACE_CURVE('',#18878,(#18882,#18889),.PCURVE_S1.); +#18878 = LINE('',#18879,#18880); +#18879 = CARTESIAN_POINT('',(-19.85000000011,-62.60000000004,31.8)); +#18880 = VECTOR('',#18881,1.); +#18881 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18882 = PCURVE('',#3842,#18883); +#18883 = DEFINITIONAL_REPRESENTATION('',(#18884),#18888); +#18884 = LINE('',#18885,#18886); +#18885 = CARTESIAN_POINT('',(-13.65000000001,2.849999999989)); +#18886 = VECTOR('',#18887,1.); +#18887 = DIRECTION('',(0.707106781187,0.707106781187)); +#18888 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18889 = PCURVE('',#7777,#18890); +#18890 = DEFINITIONAL_REPRESENTATION('',(#18891),#18895); +#18891 = LINE('',#18892,#18893); +#18892 = CARTESIAN_POINT('',(1.71589906218E-14,2.)); +#18893 = VECTOR('',#18894,1.); +#18894 = DIRECTION('',(1.,1.854674126415E-29)); +#18895 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18896 = FACE_BOUND('',#18897,.T.); +#18897 = EDGE_LOOP('',(#18898,#18923,#18946,#18969)); +#18898 = ORIENTED_EDGE('',*,*,#18899,.F.); +#18899 = EDGE_CURVE('',#18900,#18902,#18904,.T.); +#18900 = VERTEX_POINT('',#18901); +#18901 = CARTESIAN_POINT('',(-16.55000000011,-62.60000000004,31.5)); +#18902 = VERTEX_POINT('',#18903); +#18903 = CARTESIAN_POINT('',(-13.55000000011,-62.60000000005,31.5)); +#18904 = SURFACE_CURVE('',#18905,(#18909,#18916),.PCURVE_S1.); +#18905 = LINE('',#18906,#18907); +#18906 = CARTESIAN_POINT('',(-26.00000000009,-62.60000000003,31.5)); +#18907 = VECTOR('',#18908,1.); +#18908 = DIRECTION('',(1.,-1.439064838363E-12,1.344570331296E-27)); +#18909 = PCURVE('',#3842,#18910); +#18910 = DEFINITIONAL_REPRESENTATION('',(#18911),#18915); +#18911 = LINE('',#18912,#18913); +#18912 = CARTESIAN_POINT('',(-13.35000000001,-3.29999999999)); +#18913 = VECTOR('',#18914,1.); +#18914 = DIRECTION('',(-5.560352306441E-42,1.)); +#18915 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18916 = PCURVE('',#8110,#18917); +#18917 = DEFINITIONAL_REPRESENTATION('',(#18918),#18922); +#18918 = LINE('',#18919,#18920); +#18919 = CARTESIAN_POINT('',(2.443739885391E-14,2.)); +#18920 = VECTOR('',#18921,1.); +#18921 = DIRECTION('',(1.,-2.343516320473E-42)); +#18922 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18923 = ORIENTED_EDGE('',*,*,#18924,.F.); +#18924 = EDGE_CURVE('',#18925,#18900,#18927,.T.); +#18925 = VERTEX_POINT('',#18926); +#18926 = CARTESIAN_POINT('',(3.449999999885,-62.60000000007,11.5)); +#18927 = SURFACE_CURVE('',#18928,(#18932,#18939),.PCURVE_S1.); +#18928 = LINE('',#18929,#18930); +#18929 = CARTESIAN_POINT('',(-16.85000000011,-62.60000000004,31.8)); +#18930 = VECTOR('',#18931,1.); +#18931 = DIRECTION('',(-0.707106781187,1.017632935685E-12,0.707106781187 + )); +#18932 = PCURVE('',#3842,#18933); +#18933 = DEFINITIONAL_REPRESENTATION('',(#18934),#18938); +#18934 = LINE('',#18935,#18936); +#18935 = CARTESIAN_POINT('',(-13.65000000001,5.849999999989)); +#18936 = VECTOR('',#18937,1.); +#18937 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#18938 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18939 = PCURVE('',#8084,#18940); +#18940 = DEFINITIONAL_REPRESENTATION('',(#18941),#18945); +#18941 = LINE('',#18942,#18943); +#18942 = CARTESIAN_POINT('',(35.779603128055,2.)); +#18943 = VECTOR('',#18944,1.); +#18944 = DIRECTION('',(1.,-8.10752882526E-29)); +#18945 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18946 = ORIENTED_EDGE('',*,*,#18947,.F.); +#18947 = EDGE_CURVE('',#18948,#18925,#18950,.T.); +#18948 = VERTEX_POINT('',#18949); +#18949 = CARTESIAN_POINT('',(6.449999999885,-62.60000000008,11.5)); +#18950 = SURFACE_CURVE('',#18951,(#18955,#18962),.PCURVE_S1.); +#18951 = LINE('',#18952,#18953); +#18952 = CARTESIAN_POINT('',(21.999999999933,-62.6000000001,11.5)); +#18953 = VECTOR('',#18954,1.); +#18954 = DIRECTION('',(-1.,1.439064838363E-12,-1.344570331296E-27)); +#18955 = PCURVE('',#3842,#18956); +#18956 = DEFINITIONAL_REPRESENTATION('',(#18957),#18961); +#18957 = LINE('',#18958,#18959); +#18958 = CARTESIAN_POINT('',(6.649999999987,44.700000000037)); +#18959 = VECTOR('',#18960,1.); +#18960 = DIRECTION('',(5.560352306441E-42,-1.)); +#18961 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18962 = PCURVE('',#8056,#18963); +#18963 = DEFINITIONAL_REPRESENTATION('',(#18964),#18968); +#18964 = LINE('',#18965,#18966); +#18965 = CARTESIAN_POINT('',(-2.08846851751E-14,2.)); +#18966 = VECTOR('',#18967,1.); +#18967 = DIRECTION('',(1.,2.343516320473E-42)); +#18968 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18969 = ORIENTED_EDGE('',*,*,#18970,.F.); +#18970 = EDGE_CURVE('',#18902,#18948,#18971,.T.); +#18971 = SURFACE_CURVE('',#18972,(#18976,#18983),.PCURVE_S1.); +#18972 = LINE('',#18973,#18974); +#18973 = CARTESIAN_POINT('',(-13.85000000011,-62.60000000005,31.8)); +#18974 = VECTOR('',#18975,1.); +#18975 = DIRECTION('',(0.707106781187,-1.017632935685E-12, + -0.707106781187)); +#18976 = PCURVE('',#3842,#18977); +#18977 = DEFINITIONAL_REPRESENTATION('',(#18978),#18982); +#18978 = LINE('',#18979,#18980); +#18979 = CARTESIAN_POINT('',(-13.65000000001,8.849999999989)); +#18980 = VECTOR('',#18981,1.); +#18981 = DIRECTION('',(0.707106781187,0.707106781187)); +#18982 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18983 = PCURVE('',#8028,#18984); +#18984 = DEFINITIONAL_REPRESENTATION('',(#18985),#18989); +#18985 = LINE('',#18986,#18987); +#18986 = CARTESIAN_POINT('',(1.71589906218E-14,2.)); +#18987 = VECTOR('',#18988,1.); +#18988 = DIRECTION('',(1.,1.854674126415E-29)); +#18989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#18990 = ADVANCED_FACE('',(#18991),#7022,.F.); +#18991 = FACE_BOUND('',#18992,.T.); +#18992 = EDGE_LOOP('',(#18993,#19014,#19015,#19036)); +#18993 = ORIENTED_EDGE('',*,*,#18994,.T.); +#18994 = EDGE_CURVE('',#7007,#18319,#18995,.T.); +#18995 = SURFACE_CURVE('',#18996,(#19000,#19007),.PCURVE_S1.); +#18996 = LINE('',#18997,#18998); +#18997 = CARTESIAN_POINT('',(19.449999999882,-64.60000000009,31.5)); +#18998 = VECTOR('',#18999,1.); +#18999 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19000 = PCURVE('',#7022,#19001); +#19001 = DEFINITIONAL_REPRESENTATION('',(#19002),#19006); +#19002 = LINE('',#19003,#19004); +#19003 = CARTESIAN_POINT('',(45.449999999979,7.143504210492E-15)); +#19004 = VECTOR('',#19005,1.); +#19005 = DIRECTION('',(2.286638207901E-16,1.)); +#19006 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19007 = PCURVE('',#7071,#19008); +#19008 = DEFINITIONAL_REPRESENTATION('',(#19009),#19013); +#19009 = LINE('',#19010,#19011); +#19010 = CARTESIAN_POINT('',(35.355339059344,3.154836922983E-14)); +#19011 = VECTOR('',#19012,1.); +#19012 = DIRECTION('',(-1.397496474766E-15,1.)); +#19013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19014 = ORIENTED_EDGE('',*,*,#18318,.T.); +#19015 = ORIENTED_EDGE('',*,*,#19016,.F.); +#19016 = EDGE_CURVE('',#7005,#18296,#19017,.T.); +#19017 = SURFACE_CURVE('',#19018,(#19022,#19029),.PCURVE_S1.); +#19018 = LINE('',#19019,#19020); +#19019 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,31.5)); +#19020 = VECTOR('',#19021,1.); +#19021 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19022 = PCURVE('',#7022,#19023); +#19023 = DEFINITIONAL_REPRESENTATION('',(#19024),#19028); +#19024 = LINE('',#19025,#19026); +#19025 = CARTESIAN_POINT('',(48.000000000027,-1.80633838466E-14)); +#19026 = VECTOR('',#19027,1.); +#19027 = DIRECTION('',(2.286638207901E-16,1.)); +#19028 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19029 = PCURVE('',#3870,#19030); +#19030 = DEFINITIONAL_REPRESENTATION('',(#19031),#19035); +#19031 = LINE('',#19032,#19033); +#19032 = CARTESIAN_POINT('',(0.,0.)); +#19033 = VECTOR('',#19034,1.); +#19034 = DIRECTION('',(1.747694647186E-15,1.)); +#19035 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19036 = ORIENTED_EDGE('',*,*,#7004,.T.); +#19037 = ADVANCED_FACE('',(#19038),#7417,.F.); +#19038 = FACE_BOUND('',#19039,.T.); +#19039 = EDGE_LOOP('',(#19040,#19061,#19062,#19083)); +#19040 = ORIENTED_EDGE('',*,*,#19041,.T.); +#19041 = EDGE_CURVE('',#7402,#18411,#19042,.T.); +#19042 = SURFACE_CURVE('',#19043,(#19047,#19054),.PCURVE_S1.); +#19043 = LINE('',#19044,#19045); +#19044 = CARTESIAN_POINT('',(13.449999999882,-64.60000000009,31.5)); +#19045 = VECTOR('',#19046,1.); +#19046 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19047 = PCURVE('',#7417,#19048); +#19048 = DEFINITIONAL_REPRESENTATION('',(#19049),#19053); +#19049 = LINE('',#19050,#19051); +#19050 = CARTESIAN_POINT('',(39.449999999979,-2.96784232706E-14)); +#19051 = VECTOR('',#19052,1.); +#19052 = DIRECTION('',(2.286638207901E-16,1.)); +#19053 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19054 = PCURVE('',#7494,#19055); +#19055 = DEFINITIONAL_REPRESENTATION('',(#19056),#19060); +#19056 = LINE('',#19057,#19058); +#19057 = CARTESIAN_POINT('',(35.355339059344,3.154836922983E-14)); +#19058 = VECTOR('',#19059,1.); +#19059 = DIRECTION('',(-1.397496474766E-15,1.)); +#19060 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19061 = ORIENTED_EDGE('',*,*,#18410,.T.); +#19062 = ORIENTED_EDGE('',*,*,#19063,.T.); +#19063 = EDGE_CURVE('',#18388,#7400,#19064,.T.); +#19064 = SURFACE_CURVE('',#19065,(#19069,#19076),.PCURVE_S1.); +#19065 = LINE('',#19066,#19067); +#19066 = CARTESIAN_POINT('',(16.449999999882,-64.60000000009,31.5)); +#19067 = VECTOR('',#19068,1.); +#19068 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19069 = PCURVE('',#7417,#19070); +#19070 = DEFINITIONAL_REPRESENTATION('',(#19071),#19075); +#19071 = LINE('',#19072,#19073); +#19072 = CARTESIAN_POINT('',(42.449999999979,-4.16203217245E-15)); +#19073 = VECTOR('',#19074,1.); +#19074 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19075 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19076 = PCURVE('',#7445,#19077); +#19077 = DEFINITIONAL_REPRESENTATION('',(#19078),#19082); +#19078 = LINE('',#19079,#19080); +#19079 = CARTESIAN_POINT('',(0.424264068711,3.384115772261E-14)); +#19080 = VECTOR('',#19081,1.); +#19081 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19082 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19083 = ORIENTED_EDGE('',*,*,#7399,.T.); +#19084 = ADVANCED_FACE('',(#19085),#7668,.F.); +#19085 = FACE_BOUND('',#19086,.T.); +#19086 = EDGE_LOOP('',(#19087,#19108,#19109,#19130)); +#19087 = ORIENTED_EDGE('',*,*,#19088,.T.); +#19088 = EDGE_CURVE('',#7653,#18503,#19089,.T.); +#19089 = SURFACE_CURVE('',#19090,(#19094,#19101),.PCURVE_S1.); +#19090 = LINE('',#19091,#19092); +#19091 = CARTESIAN_POINT('',(7.449999999882,-64.60000000008,31.5)); +#19092 = VECTOR('',#19093,1.); +#19093 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19094 = PCURVE('',#7668,#19095); +#19095 = DEFINITIONAL_REPRESENTATION('',(#19096),#19100); +#19096 = LINE('',#19097,#19098); +#19097 = CARTESIAN_POINT('',(33.449999999979,-5.228949603648E-14)); +#19098 = VECTOR('',#19099,1.); +#19099 = DIRECTION('',(2.286638207901E-16,1.)); +#19100 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19101 = PCURVE('',#7745,#19102); +#19102 = DEFINITIONAL_REPRESENTATION('',(#19103),#19107); +#19103 = LINE('',#19104,#19105); +#19104 = CARTESIAN_POINT('',(35.355339059344,4.575922394503E-14)); +#19105 = VECTOR('',#19106,1.); +#19106 = DIRECTION('',(-1.397496474766E-15,1.)); +#19107 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19108 = ORIENTED_EDGE('',*,*,#18502,.T.); +#19109 = ORIENTED_EDGE('',*,*,#19110,.T.); +#19110 = EDGE_CURVE('',#18480,#7651,#19111,.T.); +#19111 = SURFACE_CURVE('',#19112,(#19116,#19123),.PCURVE_S1.); +#19112 = LINE('',#19113,#19114); +#19113 = CARTESIAN_POINT('',(10.449999999882,-64.60000000008,31.5)); +#19114 = VECTOR('',#19115,1.); +#19115 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19116 = PCURVE('',#7668,#19117); +#19117 = DEFINITIONAL_REPRESENTATION('',(#19118),#19122); +#19118 = LINE('',#19119,#19120); +#19119 = CARTESIAN_POINT('',(36.449999999979,-4.098395965354E-14)); +#19120 = VECTOR('',#19121,1.); +#19121 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19122 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19123 = PCURVE('',#7696,#19124); +#19124 = DEFINITIONAL_REPRESENTATION('',(#19125),#19129); +#19125 = LINE('',#19126,#19127); +#19126 = CARTESIAN_POINT('',(0.424264068711,3.384115772261E-14)); +#19127 = VECTOR('',#19128,1.); +#19128 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19130 = ORIENTED_EDGE('',*,*,#7650,.T.); +#19131 = ADVANCED_FACE('',(#19132),#7891,.F.); +#19132 = FACE_BOUND('',#19133,.T.); +#19133 = EDGE_LOOP('',(#19134,#19155,#19156,#19177)); +#19134 = ORIENTED_EDGE('',*,*,#19135,.T.); +#19135 = EDGE_CURVE('',#7876,#17977,#19136,.T.); +#19136 = SURFACE_CURVE('',#19137,(#19141,#19148),.PCURVE_S1.); +#19137 = LINE('',#19138,#19139); +#19138 = CARTESIAN_POINT('',(1.449999999882,-64.60000000007,31.5)); +#19139 = VECTOR('',#19140,1.); +#19140 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19141 = PCURVE('',#7891,#19142); +#19142 = DEFINITIONAL_REPRESENTATION('',(#19143),#19147); +#19143 = LINE('',#19144,#19145); +#19144 = CARTESIAN_POINT('',(27.449999999979,1.036455948885E-14)); +#19145 = VECTOR('',#19146,1.); +#19146 = DIRECTION('',(2.286638207901E-16,1.)); +#19147 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19148 = PCURVE('',#7996,#19149); +#19149 = DEFINITIONAL_REPRESENTATION('',(#19150),#19154); +#19150 = LINE('',#19151,#19152); +#19151 = CARTESIAN_POINT('',(35.355339059344,3.154836922983E-14)); +#19152 = VECTOR('',#19153,1.); +#19153 = DIRECTION('',(-1.397496474766E-15,1.)); +#19154 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19155 = ORIENTED_EDGE('',*,*,#18594,.T.); +#19156 = ORIENTED_EDGE('',*,*,#19157,.T.); +#19157 = EDGE_CURVE('',#18572,#7874,#19158,.T.); +#19158 = SURFACE_CURVE('',#19159,(#19163,#19170),.PCURVE_S1.); +#19159 = LINE('',#19160,#19161); +#19160 = CARTESIAN_POINT('',(4.449999999882,-64.60000000007,31.5)); +#19161 = VECTOR('',#19162,1.); +#19162 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19163 = PCURVE('',#7891,#19164); +#19164 = DEFINITIONAL_REPRESENTATION('',(#19165),#19169); +#19165 = LINE('',#19166,#19167); +#19166 = CARTESIAN_POINT('',(30.449999999979,-7.780588713462E-14)); +#19167 = VECTOR('',#19168,1.); +#19168 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19169 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19170 = PCURVE('',#7919,#19171); +#19171 = DEFINITIONAL_REPRESENTATION('',(#19172),#19176); +#19172 = LINE('',#19173,#19174); +#19173 = CARTESIAN_POINT('',(0.424264068711,-6.56348252838E-14)); +#19174 = VECTOR('',#19175,1.); +#19175 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19177 = ORIENTED_EDGE('',*,*,#7873,.T.); +#19178 = ADVANCED_FACE('',(#19179),#8142,.F.); +#19179 = FACE_BOUND('',#19180,.T.); +#19180 = EDGE_LOOP('',(#19181,#19202,#19203,#19224)); +#19181 = ORIENTED_EDGE('',*,*,#19182,.T.); +#19182 = EDGE_CURVE('',#8127,#18620,#19183,.T.); +#19183 = SURFACE_CURVE('',#19184,(#19188,#19195),.PCURVE_S1.); +#19184 = LINE('',#19185,#19186); +#19185 = CARTESIAN_POINT('',(-4.550000000118,-64.60000000006,31.5)); +#19186 = VECTOR('',#19187,1.); +#19187 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19188 = PCURVE('',#8142,#19189); +#19189 = DEFINITIONAL_REPRESENTATION('',(#19190),#19194); +#19190 = LINE('',#19191,#19192); +#19191 = CARTESIAN_POINT('',(21.449999999979,-2.645736799224E-14)); +#19192 = VECTOR('',#19193,1.); +#19193 = DIRECTION('',(2.286638207901E-16,1.)); +#19194 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19195 = PCURVE('',#8224,#19196); +#19196 = DEFINITIONAL_REPRESENTATION('',(#19197),#19201); +#19197 = LINE('',#19198,#19199); +#19198 = CARTESIAN_POINT('',(35.355339059344,3.154836922984E-14)); +#19199 = VECTOR('',#19200,1.); +#19200 = DIRECTION('',(-1.397496474766E-15,1.)); +#19201 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19202 = ORIENTED_EDGE('',*,*,#18688,.T.); +#19203 = ORIENTED_EDGE('',*,*,#19204,.T.); +#19204 = EDGE_CURVE('',#18666,#8125,#19205,.T.); +#19205 = SURFACE_CURVE('',#19206,(#19210,#19217),.PCURVE_S1.); +#19206 = LINE('',#19207,#19208); +#19207 = CARTESIAN_POINT('',(-1.550000000118,-64.60000000006,31.5)); +#19208 = VECTOR('',#19209,1.); +#19209 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19210 = PCURVE('',#8142,#19211); +#19211 = DEFINITIONAL_REPRESENTATION('',(#19212),#19216); +#19212 = LINE('',#19213,#19214); +#19213 = CARTESIAN_POINT('',(24.449999999979,-1.515183160929E-14)); +#19214 = VECTOR('',#19215,1.); +#19215 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19217 = PCURVE('',#8170,#19218); +#19218 = DEFINITIONAL_REPRESENTATION('',(#19219),#19223); +#19219 = LINE('',#19220,#19221); +#19220 = CARTESIAN_POINT('',(0.424264068711,1.963030300741E-14)); +#19221 = VECTOR('',#19222,1.); +#19222 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19223 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19224 = ORIENTED_EDGE('',*,*,#8124,.T.); +#19225 = ADVANCED_FACE('',(#19226),#8338,.F.); +#19226 = FACE_BOUND('',#19227,.T.); +#19227 = EDGE_LOOP('',(#19228,#19249,#19250,#19271)); +#19228 = ORIENTED_EDGE('',*,*,#19229,.T.); +#19229 = EDGE_CURVE('',#8297,#18712,#19230,.T.); +#19230 = SURFACE_CURVE('',#19231,(#19235,#19242),.PCURVE_S1.); +#19231 = LINE('',#19232,#19233); +#19232 = CARTESIAN_POINT('',(-10.55000000011,-64.60000000005,31.5)); +#19233 = VECTOR('',#19234,1.); +#19234 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19235 = PCURVE('',#8338,#19236); +#19236 = DEFINITIONAL_REPRESENTATION('',(#19237),#19241); +#19237 = LINE('',#19238,#19239); +#19238 = CARTESIAN_POINT('',(15.449999999979,3.619668753308E-14)); +#19239 = VECTOR('',#19240,1.); +#19240 = DIRECTION('',(2.286638207901E-16,1.)); +#19241 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19242 = PCURVE('',#8312,#19243); +#19243 = DEFINITIONAL_REPRESENTATION('',(#19244),#19248); +#19244 = LINE('',#19245,#19246); +#19245 = CARTESIAN_POINT('',(35.355339059344,1.310243522362E-13)); +#19246 = VECTOR('',#19247,1.); +#19247 = DIRECTION('',(-1.397496474766E-15,1.)); +#19248 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19249 = ORIENTED_EDGE('',*,*,#18711,.T.); +#19250 = ORIENTED_EDGE('',*,*,#19251,.T.); +#19251 = EDGE_CURVE('',#18714,#8239,#19252,.T.); +#19252 = SURFACE_CURVE('',#19253,(#19257,#19264),.PCURVE_S1.); +#19253 = LINE('',#19254,#19255); +#19254 = CARTESIAN_POINT('',(-7.550000000118,-64.60000000006,31.5)); +#19255 = VECTOR('',#19256,1.); +#19256 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19257 = PCURVE('',#8338,#19258); +#19258 = DEFINITIONAL_REPRESENTATION('',(#19259),#19263); +#19259 = LINE('',#19260,#19261); +#19260 = CARTESIAN_POINT('',(18.449999999979,-3.776290437518E-14)); +#19261 = VECTOR('',#19262,1.); +#19262 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19264 = PCURVE('',#8256,#19265); +#19265 = DEFINITIONAL_REPRESENTATION('',(#19266),#19270); +#19266 = LINE('',#19267,#19268); +#19267 = CARTESIAN_POINT('',(0.424264068711,3.384115772261E-14)); +#19268 = VECTOR('',#19269,1.); +#19269 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19270 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19271 = ORIENTED_EDGE('',*,*,#8324,.T.); +#19272 = ADVANCED_FACE('',(#19273),#8110,.F.); +#19273 = FACE_BOUND('',#19274,.T.); +#19274 = EDGE_LOOP('',(#19275,#19296,#19297,#19318)); +#19275 = ORIENTED_EDGE('',*,*,#19276,.T.); +#19276 = EDGE_CURVE('',#8069,#18900,#19277,.T.); +#19277 = SURFACE_CURVE('',#19278,(#19282,#19289),.PCURVE_S1.); +#19278 = LINE('',#19279,#19280); +#19279 = CARTESIAN_POINT('',(-16.55000000011,-64.60000000004,31.5)); +#19280 = VECTOR('',#19281,1.); +#19281 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19282 = PCURVE('',#8110,#19283); +#19283 = DEFINITIONAL_REPRESENTATION('',(#19284),#19288); +#19284 = LINE('',#19285,#19286); +#19285 = CARTESIAN_POINT('',(9.449999999979,-6.252399480031E-16)); +#19286 = VECTOR('',#19287,1.); +#19287 = DIRECTION('',(2.286638207901E-16,1.)); +#19288 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19289 = PCURVE('',#8084,#19290); +#19290 = DEFINITIONAL_REPRESENTATION('',(#19291),#19295); +#19291 = LINE('',#19292,#19293); +#19292 = CARTESIAN_POINT('',(35.355339059344,3.154836922983E-14)); +#19293 = VECTOR('',#19294,1.); +#19294 = DIRECTION('',(-1.397496474766E-15,1.)); +#19295 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19296 = ORIENTED_EDGE('',*,*,#18899,.T.); +#19297 = ORIENTED_EDGE('',*,*,#19298,.T.); +#19298 = EDGE_CURVE('',#18902,#8011,#19299,.T.); +#19299 = SURFACE_CURVE('',#19300,(#19304,#19311),.PCURVE_S1.); +#19300 = LINE('',#19301,#19302); +#19301 = CARTESIAN_POINT('',(-13.55000000011,-64.60000000005,31.5)); +#19302 = VECTOR('',#19303,1.); +#19303 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19304 = PCURVE('',#8110,#19305); +#19305 = DEFINITIONAL_REPRESENTATION('',(#19306),#19310); +#19306 = LINE('',#19307,#19308); +#19307 = CARTESIAN_POINT('',(12.449999999979,-7.458483185627E-14)); +#19308 = VECTOR('',#19309,1.); +#19309 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19311 = PCURVE('',#8028,#19312); +#19312 = DEFINITIONAL_REPRESENTATION('',(#19313),#19317); +#19313 = LINE('',#19314,#19315); +#19314 = CARTESIAN_POINT('',(0.424264068711,-6.563482528381E-14)); +#19315 = VECTOR('',#19316,1.); +#19316 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19317 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19318 = ORIENTED_EDGE('',*,*,#8096,.T.); +#19319 = ADVANCED_FACE('',(#19320),#7859,.F.); +#19320 = FACE_BOUND('',#19321,.T.); +#19321 = EDGE_LOOP('',(#19322,#19343,#19344,#19365)); +#19322 = ORIENTED_EDGE('',*,*,#19323,.T.); +#19323 = EDGE_CURVE('',#7818,#18806,#19324,.T.); +#19324 = SURFACE_CURVE('',#19325,(#19329,#19336),.PCURVE_S1.); +#19325 = LINE('',#19326,#19327); +#19326 = CARTESIAN_POINT('',(-22.55000000011,-64.60000000003,31.5)); +#19327 = VECTOR('',#19328,1.); +#19328 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19329 = PCURVE('',#7859,#19330); +#19330 = DEFINITIONAL_REPRESENTATION('',(#19331),#19335); +#19331 = LINE('',#19332,#19333); +#19332 = CARTESIAN_POINT('',(3.449999999979,-2.323631271389E-14)); +#19333 = VECTOR('',#19334,1.); +#19334 = DIRECTION('',(2.286638207901E-16,1.)); +#19335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19336 = PCURVE('',#7833,#19337); +#19337 = DEFINITIONAL_REPRESENTATION('',(#19338),#19342); +#19338 = LINE('',#19339,#19340); +#19339 = CARTESIAN_POINT('',(35.355339059344,4.575922394503E-14)); +#19340 = VECTOR('',#19341,1.); +#19341 = DIRECTION('',(-1.397496474766E-15,1.)); +#19342 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19343 = ORIENTED_EDGE('',*,*,#18805,.T.); +#19344 = ORIENTED_EDGE('',*,*,#19345,.T.); +#19345 = EDGE_CURVE('',#18808,#7760,#19346,.T.); +#19346 = SURFACE_CURVE('',#19347,(#19351,#19358),.PCURVE_S1.); +#19347 = LINE('',#19348,#19349); +#19348 = CARTESIAN_POINT('',(-19.55000000011,-64.60000000004,31.5)); +#19349 = VECTOR('',#19350,1.); +#19350 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19351 = PCURVE('',#7859,#19352); +#19352 = DEFINITIONAL_REPRESENTATION('',(#19353),#19357); +#19353 = LINE('',#19354,#19355); +#19354 = CARTESIAN_POINT('',(6.449999999979,-1.193077633095E-14)); +#19355 = VECTOR('',#19356,1.); +#19356 = DIRECTION('',(-2.286638207901E-16,-1.)); +#19357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19358 = PCURVE('',#7777,#19359); +#19359 = DEFINITIONAL_REPRESENTATION('',(#19360),#19364); +#19360 = LINE('',#19361,#19362); +#19361 = CARTESIAN_POINT('',(0.424264068711,3.384115772261E-14)); +#19362 = VECTOR('',#19363,1.); +#19363 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19364 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19365 = ORIENTED_EDGE('',*,*,#7845,.T.); +#19366 = ADVANCED_FACE('',(#19367),#7610,.F.); +#19367 = FACE_BOUND('',#19368,.T.); +#19368 = EDGE_LOOP('',(#19369,#19390,#19391,#19412)); +#19369 = ORIENTED_EDGE('',*,*,#19370,.T.); +#19370 = EDGE_CURVE('',#7567,#13040,#19371,.T.); +#19371 = SURFACE_CURVE('',#19372,(#19376,#19383),.PCURVE_S1.); +#19372 = LINE('',#19373,#19374); +#19373 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 28.949999999979)); +#19374 = VECTOR('',#19375,1.); +#19375 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19376 = PCURVE('',#7610,#19377); +#19377 = DEFINITIONAL_REPRESENTATION('',(#19378),#19382); +#19378 = LINE('',#19379,#19380); +#19379 = CARTESIAN_POINT('',(17.449999999979,1.271956375565E-14)); +#19380 = VECTOR('',#19381,1.); +#19381 = DIRECTION('',(-1.747694647186E-15,1.)); +#19382 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19383 = PCURVE('',#7582,#19384); +#19384 = DEFINITIONAL_REPRESENTATION('',(#19385),#19389); +#19385 = LINE('',#19386,#19387); +#19386 = CARTESIAN_POINT('',(31.749094475262,1.0603538918E-13)); +#19387 = VECTOR('',#19388,1.); +#19388 = DIRECTION('',(-1.397496474766E-15,1.)); +#19389 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19390 = ORIENTED_EDGE('',*,*,#13039,.T.); +#19391 = ORIENTED_EDGE('',*,*,#19392,.F.); +#19392 = EDGE_CURVE('',#7595,#13017,#19393,.T.); +#19393 = SURFACE_CURVE('',#19394,(#19398,#19405),.PCURVE_S1.); +#19394 = LINE('',#19395,#19396); +#19395 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,31.5)); +#19396 = VECTOR('',#19397,1.); +#19397 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19398 = PCURVE('',#7610,#19399); +#19399 = DEFINITIONAL_REPRESENTATION('',(#19400),#19404); +#19400 = LINE('',#19401,#19402); +#19401 = CARTESIAN_POINT('',(20.,1.250163871571E-14)); +#19402 = VECTOR('',#19403,1.); +#19403 = DIRECTION('',(-1.747694647186E-15,1.)); +#19404 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19405 = PCURVE('',#7636,#19406); +#19406 = DEFINITIONAL_REPRESENTATION('',(#19407),#19411); +#19407 = LINE('',#19408,#19409); +#19408 = CARTESIAN_POINT('',(0.,0.)); +#19409 = VECTOR('',#19410,1.); +#19410 = DIRECTION('',(2.286638207901E-16,1.)); +#19411 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19412 = ORIENTED_EDGE('',*,*,#7594,.T.); +#19413 = ADVANCED_FACE('',(#19414),#7185,.F.); +#19414 = FACE_BOUND('',#19415,.T.); +#19415 = EDGE_LOOP('',(#19416,#19437,#19438,#19459)); +#19416 = ORIENTED_EDGE('',*,*,#19417,.T.); +#19417 = EDGE_CURVE('',#7144,#12817,#19418,.T.); +#19418 = SURFACE_CURVE('',#19419,(#19423,#19430),.PCURVE_S1.); +#19419 = LINE('',#19420,#19421); +#19420 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 16.949999999979)); +#19421 = VECTOR('',#19422,1.); +#19422 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19423 = PCURVE('',#7185,#19424); +#19424 = DEFINITIONAL_REPRESENTATION('',(#19425),#19429); +#19425 = LINE('',#19426,#19427); +#19426 = CARTESIAN_POINT('',(5.449999999979,-4.657613598603E-16)); +#19427 = VECTOR('',#19428,1.); +#19428 = DIRECTION('',(-1.747694647186E-15,1.)); +#19429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19430 = PCURVE('',#7159,#19431); +#19431 = DEFINITIONAL_REPRESENTATION('',(#19432),#19436); +#19432 = LINE('',#19433,#19434); +#19433 = CARTESIAN_POINT('',(14.778531726785,5.280708130495E-14)); +#19434 = VECTOR('',#19435,1.); +#19435 = DIRECTION('',(-1.397496474766E-15,1.)); +#19436 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19437 = ORIENTED_EDGE('',*,*,#12816,.T.); +#19438 = ORIENTED_EDGE('',*,*,#19439,.T.); +#19439 = EDGE_CURVE('',#12787,#7086,#19440,.T.); +#19440 = SURFACE_CURVE('',#19441,(#19445,#19452),.PCURVE_S1.); +#19441 = LINE('',#19442,#19443); +#19442 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 19.949999999979)); +#19443 = VECTOR('',#19444,1.); +#19444 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19445 = PCURVE('',#7185,#19446); +#19446 = DEFINITIONAL_REPRESENTATION('',(#19447),#19451); +#19447 = LINE('',#19448,#19449); +#19448 = CARTESIAN_POINT('',(8.449999999979,-7.221437597844E-16)); +#19449 = VECTOR('',#19450,1.); +#19450 = DIRECTION('',(1.747694647186E-15,-1.)); +#19451 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19452 = PCURVE('',#7103,#19453); +#19453 = DEFINITIONAL_REPRESENTATION('',(#19454),#19458); +#19454 = LINE('',#19455,#19456); +#19455 = CARTESIAN_POINT('',(16.75843071415,2.932709629966E-14)); +#19456 = VECTOR('',#19457,1.); +#19457 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19458 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19459 = ORIENTED_EDGE('',*,*,#7171,.T.); +#19460 = ADVANCED_FACE('',(#19461),#7271,.F.); +#19461 = FACE_BOUND('',#19462,.T.); +#19462 = EDGE_LOOP('',(#19463,#19484,#19485,#19506)); +#19463 = ORIENTED_EDGE('',*,*,#19464,.T.); +#19464 = EDGE_CURVE('',#12687,#7200,#19465,.T.); +#19465 = SURFACE_CURVE('',#19466,(#19470,#19477),.PCURVE_S1.); +#19466 = LINE('',#19467,#19468); +#19467 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 13.949999999979)); +#19468 = VECTOR('',#19469,1.); +#19469 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19470 = PCURVE('',#7271,#19471); +#19471 = DEFINITIONAL_REPRESENTATION('',(#19472),#19476); +#19472 = LINE('',#19473,#19474); +#19473 = CARTESIAN_POINT('',(2.449999999979,-9.968536196635E-14)); +#19474 = VECTOR('',#19475,1.); +#19475 = DIRECTION('',(1.747694647186E-15,-1.)); +#19476 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19477 = PCURVE('',#7217,#19478); +#19478 = DEFINITIONAL_REPRESENTATION('',(#19479),#19483); +#19479 = LINE('',#19480,#19481); +#19480 = CARTESIAN_POINT('',(25.243712088389,-3.281419442579E-14)); +#19481 = VECTOR('',#19482,1.); +#19482 = DIRECTION('',(-1.397496474766E-15,-1.)); +#19483 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19484 = ORIENTED_EDGE('',*,*,#7257,.T.); +#19485 = ORIENTED_EDGE('',*,*,#19486,.T.); +#19486 = EDGE_CURVE('',#7230,#12717,#19487,.T.); +#19487 = SURFACE_CURVE('',#19488,(#19492,#19499),.PCURVE_S1.); +#19488 = LINE('',#19489,#19490); +#19489 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003,11.5)); +#19490 = VECTOR('',#19491,1.); +#19491 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19492 = PCURVE('',#7271,#19493); +#19493 = DEFINITIONAL_REPRESENTATION('',(#19494),#19498); +#19494 = LINE('',#19495,#19496); +#19495 = CARTESIAN_POINT('',(-0.,0.)); +#19496 = VECTOR('',#19497,1.); +#19497 = DIRECTION('',(-1.747694647186E-15,1.)); +#19498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19499 = PCURVE('',#7245,#19500); +#19500 = DEFINITIONAL_REPRESENTATION('',(#19501),#19505); +#19501 = LINE('',#19502,#19503); +#19502 = CARTESIAN_POINT('',(48.000000000027,1.80633838466E-14)); +#19503 = VECTOR('',#19504,1.); +#19504 = DIRECTION('',(-2.286638207901E-16,1.)); +#19505 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19506 = ORIENTED_EDGE('',*,*,#12716,.T.); +#19507 = ADVANCED_FACE('',(#19508,#19670,#19673),#3870,.F.); +#19508 = FACE_BOUND('',#19509,.T.); +#19509 = EDGE_LOOP('',(#19510,#19531,#19532,#19533,#19534,#19535,#19536, + #19537,#19538,#19559,#19560,#19581,#19582,#19603,#19604,#19625, + #19626,#19647,#19648,#19669)); +#19510 = ORIENTED_EDGE('',*,*,#19511,.T.); +#19511 = EDGE_CURVE('',#18342,#7035,#19512,.T.); +#19512 = SURFACE_CURVE('',#19513,(#19517,#19524),.PCURVE_S1.); +#19513 = LINE('',#19514,#19515); +#19514 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 28.949999999952)); +#19515 = VECTOR('',#19516,1.); +#19516 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19517 = PCURVE('',#3870,#19518); +#19518 = DEFINITIONAL_REPRESENTATION('',(#19519),#19523); +#19519 = LINE('',#19520,#19521); +#19520 = CARTESIAN_POINT('',(2.550000000048,2.179250399396E-16)); +#19521 = VECTOR('',#19522,1.); +#19522 = DIRECTION('',(-1.747694647186E-15,-1.)); +#19523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19524 = PCURVE('',#7071,#19525); +#19525 = DEFINITIONAL_REPRESENTATION('',(#19526),#19530); +#19526 = LINE('',#19527,#19528); +#19527 = CARTESIAN_POINT('',(31.749094475224,6.559406212706E-15)); +#19528 = VECTOR('',#19529,1.); +#19529 = DIRECTION('',(1.397496474766E-15,-1.)); +#19530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19531 = ORIENTED_EDGE('',*,*,#7034,.T.); +#19532 = ORIENTED_EDGE('',*,*,#19016,.T.); +#19533 = ORIENTED_EDGE('',*,*,#18295,.F.); +#19534 = ORIENTED_EDGE('',*,*,#12555,.F.); +#19535 = ORIENTED_EDGE('',*,*,#13305,.T.); +#19536 = ORIENTED_EDGE('',*,*,#3854,.T.); +#19537 = ORIENTED_EDGE('',*,*,#18022,.F.); +#19538 = ORIENTED_EDGE('',*,*,#19539,.F.); +#19539 = EDGE_CURVE('',#7932,#18000,#19540,.T.); +#19540 = SURFACE_CURVE('',#19541,(#19545,#19552),.PCURVE_S1.); +#19541 = LINE('',#19542,#19543); +#19542 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001,11.5)); +#19543 = VECTOR('',#19544,1.); +#19544 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19545 = PCURVE('',#3870,#19546); +#19546 = DEFINITIONAL_REPRESENTATION('',(#19547),#19551); +#19547 = LINE('',#19548,#19549); +#19548 = CARTESIAN_POINT('',(20.,-1.250163871571E-14)); +#19549 = VECTOR('',#19550,1.); +#19550 = DIRECTION('',(1.747694647186E-15,1.)); +#19551 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19552 = PCURVE('',#7970,#19553); +#19553 = DEFINITIONAL_REPRESENTATION('',(#19554),#19558); +#19554 = LINE('',#19555,#19556); +#19555 = CARTESIAN_POINT('',(0.,0.)); +#19556 = VECTOR('',#19557,1.); +#19557 = DIRECTION('',(-2.286638207901E-16,1.)); +#19558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19559 = ORIENTED_EDGE('',*,*,#7931,.T.); +#19560 = ORIENTED_EDGE('',*,*,#19561,.T.); +#19561 = EDGE_CURVE('',#7904,#18549,#19562,.T.); +#19562 = SURFACE_CURVE('',#19563,(#19567,#19574),.PCURVE_S1.); +#19563 = LINE('',#19564,#19565); +#19564 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 13.949999999952)); +#19565 = VECTOR('',#19566,1.); +#19566 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19567 = PCURVE('',#3870,#19568); +#19568 = DEFINITIONAL_REPRESENTATION('',(#19569),#19573); +#19569 = LINE('',#19570,#19571); +#19570 = CARTESIAN_POINT('',(17.550000000048,-1.121870006821E-13)); +#19571 = VECTOR('',#19572,1.); +#19572 = DIRECTION('',(1.747694647186E-15,1.)); +#19573 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19574 = PCURVE('',#7919,#19575); +#19575 = DEFINITIONAL_REPRESENTATION('',(#19576),#19580); +#19576 = LINE('',#19577,#19578); +#19577 = CARTESIAN_POINT('',(25.243712088427,-1.180793226779E-13)); +#19578 = VECTOR('',#19579,1.); +#19579 = DIRECTION('',(1.397496474766E-15,1.)); +#19580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19581 = ORIENTED_EDGE('',*,*,#18548,.F.); +#19582 = ORIENTED_EDGE('',*,*,#19583,.T.); +#19583 = EDGE_CURVE('',#18526,#7709,#19584,.T.); +#19584 = SURFACE_CURVE('',#19585,(#19589,#19596),.PCURVE_S1.); +#19585 = LINE('',#19586,#19587); +#19586 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 16.949999999952)); +#19587 = VECTOR('',#19588,1.); +#19588 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19589 = PCURVE('',#3870,#19590); +#19590 = DEFINITIONAL_REPRESENTATION('',(#19591),#19595); +#19591 = LINE('',#19592,#19593); +#19592 = CARTESIAN_POINT('',(14.550000000049,-1.296740007557E-14)); +#19593 = VECTOR('',#19594,1.); +#19594 = DIRECTION('',(-1.747694647186E-15,-1.)); +#19595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19596 = PCURVE('',#7745,#19597); +#19597 = DEFINITIONAL_REPRESENTATION('',(#19598),#19602); +#19598 = LINE('',#19599,#19600); +#19599 = CARTESIAN_POINT('',(14.778531726747,6.70179360593E-14)); +#19600 = VECTOR('',#19601,1.); +#19601 = DIRECTION('',(1.397496474766E-15,-1.)); +#19602 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19603 = ORIENTED_EDGE('',*,*,#7708,.T.); +#19604 = ORIENTED_EDGE('',*,*,#19605,.T.); +#19605 = EDGE_CURVE('',#7681,#18457,#19606,.T.); +#19606 = SURFACE_CURVE('',#19607,(#19611,#19618),.PCURVE_S1.); +#19607 = LINE('',#19608,#19609); +#19608 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 19.949999999952)); +#19609 = VECTOR('',#19610,1.); +#19610 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19611 = PCURVE('',#3870,#19612); +#19612 = DEFINITIONAL_REPRESENTATION('',(#19613),#19617); +#19613 = LINE('',#19614,#19615); +#19614 = CARTESIAN_POINT('',(11.550000000048,-1.322378247549E-14)); +#19615 = VECTOR('',#19616,1.); +#19616 = DIRECTION('',(1.747694647186E-15,1.)); +#19617 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19618 = PCURVE('',#7696,#19619); +#19619 = DEFINITIONAL_REPRESENTATION('',(#19620),#19624); +#19620 = LINE('',#19621,#19622); +#19621 = CARTESIAN_POINT('',(16.758430714189,4.353795105401E-14)); +#19622 = VECTOR('',#19623,1.); +#19623 = DIRECTION('',(1.397496474766E-15,1.)); +#19624 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19625 = ORIENTED_EDGE('',*,*,#18456,.F.); +#19626 = ORIENTED_EDGE('',*,*,#19627,.T.); +#19627 = EDGE_CURVE('',#18434,#7458,#19628,.T.); +#19628 = SURFACE_CURVE('',#19629,(#19633,#19640),.PCURVE_S1.); +#19629 = LINE('',#19630,#19631); +#19630 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 22.949999999952)); +#19631 = VECTOR('',#19632,1.); +#19632 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19633 = PCURVE('',#3870,#19634); +#19634 = DEFINITIONAL_REPRESENTATION('',(#19635),#19639); +#19635 = LINE('',#19636,#19637); +#19636 = CARTESIAN_POINT('',(8.550000000049,7.306898397878E-16)); +#19637 = VECTOR('',#19638,1.); +#19638 = DIRECTION('',(-1.747694647186E-15,-1.)); +#19639 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19640 = PCURVE('',#7494,#19641); +#19641 = DEFINITIONAL_REPRESENTATION('',(#19642),#19646); +#19642 = LINE('',#19643,#19644); +#19643 = CARTESIAN_POINT('',(23.263813100985,4.389409849356E-14)); +#19644 = VECTOR('',#19645,1.); +#19645 = DIRECTION('',(1.397496474766E-15,-1.)); +#19646 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19647 = ORIENTED_EDGE('',*,*,#7457,.T.); +#19648 = ORIENTED_EDGE('',*,*,#19649,.T.); +#19649 = EDGE_CURVE('',#7430,#18365,#19650,.T.); +#19650 = SURFACE_CURVE('',#19651,(#19655,#19662),.PCURVE_S1.); +#19651 = LINE('',#19652,#19653); +#19652 = CARTESIAN_POINT('',(21.99999999993,-64.6000000001, + 25.949999999952)); +#19653 = VECTOR('',#19654,1.); +#19654 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19655 = PCURVE('',#3870,#19656); +#19656 = DEFINITIONAL_REPRESENTATION('',(#19657),#19661); +#19657 = LINE('',#19658,#19659); +#19658 = CARTESIAN_POINT('',(5.550000000048,4.743074398637E-16)); +#19659 = VECTOR('',#19660,1.); +#19660 = DIRECTION('',(1.747694647186E-15,1.)); +#19661 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19662 = PCURVE('',#7445,#19663); +#19663 = DEFINITIONAL_REPRESENTATION('',(#19664),#19668); +#19664 = LINE('',#19665,#19666); +#19665 = CARTESIAN_POINT('',(8.27314933995,2.041411348832E-14)); +#19666 = VECTOR('',#19667,1.); +#19667 = DIRECTION('',(1.397496474766E-15,1.)); +#19668 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19669 = ORIENTED_EDGE('',*,*,#18364,.F.); +#19670 = FACE_BOUND('',#19671,.T.); +#19671 = EDGE_LOOP('',(#19672)); +#19672 = ORIENTED_EDGE('',*,*,#13171,.T.); +#19673 = FACE_BOUND('',#19674,.T.); +#19674 = EDGE_LOOP('',(#19675)); +#19675 = ORIENTED_EDGE('',*,*,#13258,.T.); +#19676 = ADVANCED_FACE('',(#19677),#7970,.F.); +#19677 = FACE_BOUND('',#19678,.T.); +#19678 = EDGE_LOOP('',(#19679,#19700,#19701,#19702)); +#19679 = ORIENTED_EDGE('',*,*,#19680,.T.); +#19680 = EDGE_CURVE('',#17975,#7955,#19681,.T.); +#19681 = SURFACE_CURVE('',#19682,(#19686,#19693),.PCURVE_S1.); +#19682 = LINE('',#19683,#19684); +#19683 = CARTESIAN_POINT('',(21.449999999882,-64.6000000001,11.5)); +#19684 = VECTOR('',#19685,1.); +#19685 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19686 = PCURVE('',#7970,#19687); +#19687 = DEFINITIONAL_REPRESENTATION('',(#19688),#19692); +#19688 = LINE('',#19689,#19690); +#19689 = CARTESIAN_POINT('',(0.550000000049,4.322202881555E-15)); +#19690 = VECTOR('',#19691,1.); +#19691 = DIRECTION('',(2.286638207901E-16,-1.)); +#19692 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19693 = PCURVE('',#7996,#19694); +#19694 = DEFINITIONAL_REPRESENTATION('',(#19695),#19699); +#19695 = LINE('',#19696,#19697); +#19696 = CARTESIAN_POINT('',(7.071067811882,-5.059009939903E-15)); +#19697 = VECTOR('',#19698,1.); +#19698 = DIRECTION('',(1.397496474766E-15,-1.)); +#19699 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19700 = ORIENTED_EDGE('',*,*,#7954,.T.); +#19701 = ORIENTED_EDGE('',*,*,#19539,.T.); +#19702 = ORIENTED_EDGE('',*,*,#17999,.T.); +#19703 = ADVANCED_FACE('',(#19704),#8198,.F.); +#19704 = FACE_BOUND('',#19705,.T.); +#19705 = EDGE_LOOP('',(#19706,#19727,#19728,#19749)); +#19706 = ORIENTED_EDGE('',*,*,#19707,.T.); +#19707 = EDGE_CURVE('',#18618,#8183,#19708,.T.); +#19708 = SURFACE_CURVE('',#19709,(#19713,#19720),.PCURVE_S1.); +#19709 = LINE('',#19710,#19711); +#19710 = CARTESIAN_POINT('',(15.449999999882,-64.60000000009,11.5)); +#19711 = VECTOR('',#19712,1.); +#19712 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19713 = PCURVE('',#8198,#19714); +#19714 = DEFINITIONAL_REPRESENTATION('',(#19715),#19719); +#19715 = LINE('',#19716,#19717); +#19716 = CARTESIAN_POINT('',(6.550000000049,-3.249972459953E-14)); +#19717 = VECTOR('',#19718,1.); +#19718 = DIRECTION('',(2.286638207901E-16,-1.)); +#19719 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19720 = PCURVE('',#8224,#19721); +#19721 = DEFINITIONAL_REPRESENTATION('',(#19722),#19726); +#19722 = LINE('',#19723,#19724); +#19723 = CARTESIAN_POINT('',(7.071067811882,-5.059009939893E-15)); +#19724 = VECTOR('',#19725,1.); +#19725 = DIRECTION('',(1.397496474766E-15,-1.)); +#19726 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19727 = ORIENTED_EDGE('',*,*,#8182,.T.); +#19728 = ORIENTED_EDGE('',*,*,#19729,.T.); +#19729 = EDGE_CURVE('',#8155,#18643,#19730,.T.); +#19730 = SURFACE_CURVE('',#19731,(#19735,#19742),.PCURVE_S1.); +#19731 = LINE('',#19732,#19733); +#19732 = CARTESIAN_POINT('',(18.449999999882,-64.60000000009,11.5)); +#19733 = VECTOR('',#19734,1.); +#19734 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19735 = PCURVE('',#8198,#19736); +#19736 = DEFINITIONAL_REPRESENTATION('',(#19737),#19741); +#19737 = LINE('',#19738,#19739); +#19738 = CARTESIAN_POINT('',(3.550000000048,-6.983333500375E-15)); +#19739 = VECTOR('',#19740,1.); +#19740 = DIRECTION('',(-2.286638207901E-16,1.)); +#19741 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19742 = PCURVE('',#8170,#19743); +#19743 = DEFINITIONAL_REPRESENTATION('',(#19744),#19748); +#19744 = LINE('',#19745,#19746); +#19745 = CARTESIAN_POINT('',(28.708535316173,-2.76622144605E-15)); +#19746 = VECTOR('',#19747,1.); +#19747 = DIRECTION('',(1.397496474766E-15,1.)); +#19748 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19749 = ORIENTED_EDGE('',*,*,#18642,.T.); +#19750 = ADVANCED_FACE('',(#19751),#8284,.F.); +#19751 = FACE_BOUND('',#19752,.T.); +#19752 = EDGE_LOOP('',(#19753,#19774,#19775,#19796)); +#19753 = ORIENTED_EDGE('',*,*,#19754,.T.); +#19754 = EDGE_CURVE('',#18737,#8269,#19755,.T.); +#19755 = SURFACE_CURVE('',#19756,(#19760,#19767),.PCURVE_S1.); +#19756 = LINE('',#19757,#19758); +#19757 = CARTESIAN_POINT('',(9.449999999882,-64.60000000008,11.5)); +#19758 = VECTOR('',#19759,1.); +#19759 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19760 = PCURVE('',#8284,#19761); +#19761 = DEFINITIONAL_REPRESENTATION('',(#19762),#19766); +#19762 = LINE('',#19763,#19764); +#19763 = CARTESIAN_POINT('',(12.550000000049,-5.511079736542E-14)); +#19764 = VECTOR('',#19765,1.); +#19765 = DIRECTION('',(2.286638207901E-16,-1.)); +#19766 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19767 = PCURVE('',#8312,#19768); +#19768 = DEFINITIONAL_REPRESENTATION('',(#19769),#19773); +#19769 = LINE('',#19770,#19771); +#19770 = CARTESIAN_POINT('',(7.071067811882,9.151844775309E-15)); +#19771 = VECTOR('',#19772,1.); +#19772 = DIRECTION('',(1.397496474766E-15,-1.)); +#19773 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19774 = ORIENTED_EDGE('',*,*,#8268,.T.); +#19775 = ORIENTED_EDGE('',*,*,#19776,.T.); +#19776 = EDGE_CURVE('',#8241,#18760,#19777,.T.); +#19777 = SURFACE_CURVE('',#19778,(#19782,#19789),.PCURVE_S1.); +#19778 = LINE('',#19779,#19780); +#19779 = CARTESIAN_POINT('',(12.449999999882,-64.60000000008,11.5)); +#19780 = VECTOR('',#19781,1.); +#19781 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19782 = PCURVE('',#8284,#19783); +#19783 = DEFINITIONAL_REPRESENTATION('',(#19784),#19788); +#19784 = LINE('',#19785,#19786); +#19785 = CARTESIAN_POINT('',(9.550000000048,-4.380526098146E-14)); +#19786 = VECTOR('',#19787,1.); +#19787 = DIRECTION('',(-2.286638207901E-16,1.)); +#19788 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19789 = PCURVE('',#8256,#19790); +#19790 = DEFINITIONAL_REPRESENTATION('',(#19791),#19795); +#19791 = LINE('',#19792,#19793); +#19792 = CARTESIAN_POINT('',(28.708535316173,-2.76622144605E-15)); +#19793 = VECTOR('',#19794,1.); +#19794 = DIRECTION('',(1.397496474766E-15,1.)); +#19795 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19796 = ORIENTED_EDGE('',*,*,#18759,.T.); +#19797 = ADVANCED_FACE('',(#19798),#7245,.F.); +#19798 = FACE_BOUND('',#19799,.T.); +#19799 = EDGE_LOOP('',(#19800,#19821,#19822,#19823,#19824)); +#19800 = ORIENTED_EDGE('',*,*,#19801,.T.); +#19801 = EDGE_CURVE('',#7202,#18046,#19802,.T.); +#19802 = SURFACE_CURVE('',#19803,(#19807,#19814),.PCURVE_S1.); +#19803 = LINE('',#19804,#19805); +#19804 = CARTESIAN_POINT('',(-23.55000000011,-64.60000000003,11.5)); +#19805 = VECTOR('',#19806,1.); +#19806 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19807 = PCURVE('',#7245,#19808); +#19808 = DEFINITIONAL_REPRESENTATION('',(#19809),#19813); +#19809 = LINE('',#19810,#19811); +#19810 = CARTESIAN_POINT('',(45.550000000048,-5.157400513996E-14)); +#19811 = VECTOR('',#19812,1.); +#19812 = DIRECTION('',(-2.286638207901E-16,1.)); +#19813 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19814 = PCURVE('',#7217,#19815); +#19815 = DEFINITIONAL_REPRESENTATION('',(#19816),#19820); +#19816 = LINE('',#19817,#19818); +#19817 = CARTESIAN_POINT('',(28.708535316173,-2.76622144605E-15)); +#19818 = VECTOR('',#19819,1.); +#19819 = DIRECTION('',(1.397496474766E-15,1.)); +#19820 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19821 = ORIENTED_EDGE('',*,*,#18045,.T.); +#19822 = ORIENTED_EDGE('',*,*,#12739,.T.); +#19823 = ORIENTED_EDGE('',*,*,#19486,.F.); +#19824 = ORIENTED_EDGE('',*,*,#7229,.T.); +#19825 = ADVANCED_FACE('',(#19826),#8056,.F.); +#19826 = FACE_BOUND('',#19827,.T.); +#19827 = EDGE_LOOP('',(#19828,#19849,#19850,#19871)); +#19828 = ORIENTED_EDGE('',*,*,#19829,.T.); +#19829 = EDGE_CURVE('',#18925,#8041,#19830,.T.); +#19830 = SURFACE_CURVE('',#19831,(#19835,#19842),.PCURVE_S1.); +#19831 = LINE('',#19832,#19833); +#19832 = CARTESIAN_POINT('',(3.449999999882,-64.60000000007,11.5)); +#19833 = VECTOR('',#19834,1.); +#19834 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19835 = PCURVE('',#8056,#19836); +#19836 = DEFINITIONAL_REPRESENTATION('',(#19837),#19841); +#19837 = LINE('',#19838,#19839); +#19838 = CARTESIAN_POINT('',(18.550000000049,7.543258159909E-15)); +#19839 = VECTOR('',#19840,1.); +#19840 = DIRECTION('',(2.286638207901E-16,-1.)); +#19841 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19842 = PCURVE('',#8084,#19843); +#19843 = DEFINITIONAL_REPRESENTATION('',(#19844),#19848); +#19844 = LINE('',#19845,#19846); +#19845 = CARTESIAN_POINT('',(7.071067811882,9.151844775309E-15)); +#19846 = VECTOR('',#19847,1.); +#19847 = DIRECTION('',(1.397496474766E-15,-1.)); +#19848 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19849 = ORIENTED_EDGE('',*,*,#8040,.T.); +#19850 = ORIENTED_EDGE('',*,*,#19851,.T.); +#19851 = EDGE_CURVE('',#8013,#18948,#19852,.T.); +#19852 = SURFACE_CURVE('',#19853,(#19857,#19864),.PCURVE_S1.); +#19853 = LINE('',#19854,#19855); +#19854 = CARTESIAN_POINT('',(6.449999999882,-64.60000000008,11.5)); +#19855 = VECTOR('',#19856,1.); +#19856 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19857 = PCURVE('',#8056,#19858); +#19858 = DEFINITIONAL_REPRESENTATION('',(#19859),#19863); +#19859 = LINE('',#19860,#19861); +#19860 = CARTESIAN_POINT('',(15.550000000048,-8.062718846255E-14)); +#19861 = VECTOR('',#19862,1.); +#19862 = DIRECTION('',(-2.286638207901E-16,1.)); +#19863 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19864 = PCURVE('',#8028,#19865); +#19865 = DEFINITIONAL_REPRESENTATION('',(#19866),#19870); +#19866 = LINE('',#19867,#19868); +#19867 = CARTESIAN_POINT('',(28.708535316173,-1.022422044525E-13)); +#19868 = VECTOR('',#19869,1.); +#19869 = DIRECTION('',(1.397496474766E-15,1.)); +#19870 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19871 = ORIENTED_EDGE('',*,*,#18947,.T.); +#19872 = ADVANCED_FACE('',(#19873),#7131,.F.); +#19873 = FACE_BOUND('',#19874,.T.); +#19874 = EDGE_LOOP('',(#19875,#19896,#19897,#19918)); +#19875 = ORIENTED_EDGE('',*,*,#19876,.T.); +#19876 = EDGE_CURVE('',#7088,#18114,#19877,.T.); +#19877 = SURFACE_CURVE('',#19878,(#19882,#19889),.PCURVE_S1.); +#19878 = LINE('',#19879,#19880); +#19879 = CARTESIAN_POINT('',(-17.55000000011,-64.60000000004,11.5)); +#19880 = VECTOR('',#19881,1.); +#19881 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19882 = PCURVE('',#7131,#19883); +#19883 = DEFINITIONAL_REPRESENTATION('',(#19884),#19888); +#19884 = LINE('',#19885,#19886); +#19885 = CARTESIAN_POINT('',(39.550000000048,-1.475207765887E-14)); +#19886 = VECTOR('',#19887,1.); +#19887 = DIRECTION('',(-2.286638207901E-16,1.)); +#19888 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19889 = PCURVE('',#7103,#19890); +#19890 = DEFINITIONAL_REPRESENTATION('',(#19891),#19895); +#19891 = LINE('',#19892,#19893); +#19892 = CARTESIAN_POINT('',(28.708535316173,-2.76622144605E-15)); +#19893 = VECTOR('',#19894,1.); +#19894 = DIRECTION('',(1.397496474766E-15,1.)); +#19895 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19896 = ORIENTED_EDGE('',*,*,#18113,.T.); +#19897 = ORIENTED_EDGE('',*,*,#19898,.T.); +#19898 = EDGE_CURVE('',#18091,#7116,#19899,.T.); +#19899 = SURFACE_CURVE('',#19900,(#19904,#19911),.PCURVE_S1.); +#19900 = LINE('',#19901,#19902); +#19901 = CARTESIAN_POINT('',(-20.55000000011,-64.60000000004,11.5)); +#19902 = VECTOR('',#19903,1.); +#19903 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19904 = PCURVE('',#7131,#19905); +#19905 = DEFINITIONAL_REPRESENTATION('',(#19906),#19910); +#19906 = LINE('',#19907,#19908); +#19907 = CARTESIAN_POINT('',(42.550000000049,-2.605761404283E-14)); +#19908 = VECTOR('',#19909,1.); +#19909 = DIRECTION('',(2.286638207901E-16,-1.)); +#19910 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19911 = PCURVE('',#7159,#19912); +#19912 = DEFINITIONAL_REPRESENTATION('',(#19913),#19917); +#19913 = LINE('',#19914,#19915); +#19914 = CARTESIAN_POINT('',(7.071067811882,9.151844775309E-15)); +#19915 = VECTOR('',#19916,1.); +#19916 = DIRECTION('',(1.397496474766E-15,-1.)); +#19917 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19918 = ORIENTED_EDGE('',*,*,#7115,.T.); +#19919 = ADVANCED_FACE('',(#19920),#7805,.F.); +#19920 = FACE_BOUND('',#19921,.T.); +#19921 = EDGE_LOOP('',(#19922,#19943,#19944,#19965)); +#19922 = ORIENTED_EDGE('',*,*,#19923,.T.); +#19923 = EDGE_CURVE('',#18831,#7790,#19924,.T.); +#19924 = SURFACE_CURVE('',#19925,(#19929,#19936),.PCURVE_S1.); +#19925 = LINE('',#19926,#19927); +#19926 = CARTESIAN_POINT('',(-2.550000000118,-64.60000000006,11.5)); +#19927 = VECTOR('',#19928,1.); +#19928 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19929 = PCURVE('',#7805,#19930); +#19930 = DEFINITIONAL_REPRESENTATION('',(#19931),#19935); +#19931 = LINE('',#19932,#19933); +#19932 = CARTESIAN_POINT('',(24.550000000049,-2.927866932118E-14)); +#19933 = VECTOR('',#19934,1.); +#19934 = DIRECTION('',(2.286638207901E-16,-1.)); +#19935 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19936 = PCURVE('',#7833,#19937); +#19937 = DEFINITIONAL_REPRESENTATION('',(#19938),#19942); +#19938 = LINE('',#19939,#19940); +#19939 = CARTESIAN_POINT('',(7.071067811882,9.151844775309E-15)); +#19940 = VECTOR('',#19941,1.); +#19941 = DIRECTION('',(1.397496474766E-15,-1.)); +#19942 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19943 = ORIENTED_EDGE('',*,*,#7789,.T.); +#19944 = ORIENTED_EDGE('',*,*,#19945,.T.); +#19945 = EDGE_CURVE('',#7762,#18854,#19946,.T.); +#19946 = SURFACE_CURVE('',#19947,(#19951,#19958),.PCURVE_S1.); +#19947 = LINE('',#19948,#19949); +#19948 = CARTESIAN_POINT('',(0.449999999882,-64.60000000007,11.5)); +#19949 = VECTOR('',#19950,1.); +#19950 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19951 = PCURVE('',#7805,#19952); +#19952 = DEFINITIONAL_REPRESENTATION('',(#19953),#19957); +#19953 = LINE('',#19954,#19955); +#19954 = CARTESIAN_POINT('',(21.550000000048,-1.797313293708E-14)); +#19955 = VECTOR('',#19956,1.); +#19956 = DIRECTION('',(-2.286638207901E-16,1.)); +#19957 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19958 = PCURVE('',#7777,#19959); +#19959 = DEFINITIONAL_REPRESENTATION('',(#19960),#19964); +#19960 = LINE('',#19961,#19962); +#19961 = CARTESIAN_POINT('',(28.708535316173,-2.766221445973E-15)); +#19962 = VECTOR('',#19963,1.); +#19963 = DIRECTION('',(1.397496474766E-15,1.)); +#19964 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19965 = ORIENTED_EDGE('',*,*,#18853,.T.); +#19966 = ADVANCED_FACE('',(#19967),#7331,.F.); +#19967 = FACE_BOUND('',#19968,.T.); +#19968 = EDGE_LOOP('',(#19969,#19990,#19991,#20012)); +#19969 = ORIENTED_EDGE('',*,*,#19970,.T.); +#19970 = EDGE_CURVE('',#7288,#18182,#19971,.T.); +#19971 = SURFACE_CURVE('',#19972,(#19976,#19983),.PCURVE_S1.); +#19972 = LINE('',#19973,#19974); +#19973 = CARTESIAN_POINT('',(-11.55000000011,-64.60000000005,11.5)); +#19974 = VECTOR('',#19975,1.); +#19975 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#19976 = PCURVE('',#7331,#19977); +#19977 = DEFINITIONAL_REPRESENTATION('',(#19978),#19982); +#19978 = LINE('',#19979,#19980); +#19979 = CARTESIAN_POINT('',(33.550000000048,-7.74061331842E-14)); +#19980 = VECTOR('',#19981,1.); +#19981 = DIRECTION('',(-2.286638207901E-16,1.)); +#19982 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19983 = PCURVE('',#7303,#19984); +#19984 = DEFINITIONAL_REPRESENTATION('',(#19985),#19989); +#19985 = LINE('',#19986,#19987); +#19986 = CARTESIAN_POINT('',(28.708535316173,-1.022422044525E-13)); +#19987 = VECTOR('',#19988,1.); +#19988 = DIRECTION('',(1.397496474766E-15,1.)); +#19989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#19990 = ORIENTED_EDGE('',*,*,#18181,.T.); +#19991 = ORIENTED_EDGE('',*,*,#19992,.T.); +#19992 = EDGE_CURVE('',#18159,#7316,#19993,.T.); +#19993 = SURFACE_CURVE('',#19994,(#19998,#20005),.PCURVE_S1.); +#19994 = LINE('',#19995,#19996); +#19995 = CARTESIAN_POINT('',(-14.55000000011,-64.60000000005,11.5)); +#19996 = VECTOR('',#19997,1.); +#19997 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#19998 = PCURVE('',#7331,#19999); +#19999 = DEFINITIONAL_REPRESENTATION('',(#20000),#20004); +#20000 = LINE('',#20001,#20002); +#20001 = CARTESIAN_POINT('',(36.550000000049,-3.44654127694E-15)); +#20002 = VECTOR('',#20003,1.); +#20003 = DIRECTION('',(2.286638207901E-16,-1.)); +#20004 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20005 = PCURVE('',#7359,#20006); +#20006 = DEFINITIONAL_REPRESENTATION('',(#20007),#20011); +#20007 = LINE('',#20008,#20009); +#20008 = CARTESIAN_POINT('',(7.071067811882,-5.059009939893E-15)); +#20009 = VECTOR('',#20010,1.); +#20010 = DIRECTION('',(1.397496474766E-15,-1.)); +#20011 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20012 = ORIENTED_EDGE('',*,*,#7315,.T.); +#20013 = ADVANCED_FACE('',(#20014,#20020,#20023,#20026,#20029,#20032), + #3447,.F.); +#20014 = FACE_BOUND('',#20015,.T.); +#20015 = EDGE_LOOP('',(#20016,#20017,#20018,#20019)); +#20016 = ORIENTED_EDGE('',*,*,#6034,.F.); +#20017 = ORIENTED_EDGE('',*,*,#3431,.F.); +#20018 = ORIENTED_EDGE('',*,*,#6954,.F.); +#20019 = ORIENTED_EDGE('',*,*,#6059,.T.); +#20020 = FACE_BOUND('',#20021,.T.); +#20021 = EDGE_LOOP('',(#20022)); +#20022 = ORIENTED_EDGE('',*,*,#14960,.T.); +#20023 = FACE_BOUND('',#20024,.T.); +#20024 = EDGE_LOOP('',(#20025)); +#20025 = ORIENTED_EDGE('',*,*,#15042,.T.); +#20026 = FACE_BOUND('',#20027,.T.); +#20027 = EDGE_LOOP('',(#20028)); +#20028 = ORIENTED_EDGE('',*,*,#15124,.T.); +#20029 = FACE_BOUND('',#20030,.T.); +#20030 = EDGE_LOOP('',(#20031)); +#20031 = ORIENTED_EDGE('',*,*,#15206,.T.); +#20032 = FACE_BOUND('',#20033,.T.); +#20033 = EDGE_LOOP('',(#20034,#20035,#20036,#20037,#20038,#20039,#20040, + #20041)); +#20034 = ORIENTED_EDGE('',*,*,#14133,.T.); +#20035 = ORIENTED_EDGE('',*,*,#14158,.F.); +#20036 = ORIENTED_EDGE('',*,*,#14295,.T.); +#20037 = ORIENTED_EDGE('',*,*,#14482,.F.); +#20038 = ORIENTED_EDGE('',*,*,#14563,.T.); +#20039 = ORIENTED_EDGE('',*,*,#14354,.F.); +#20040 = ORIENTED_EDGE('',*,*,#14435,.T.); +#20041 = ORIENTED_EDGE('',*,*,#13991,.F.); +#20042 = ADVANCED_FACE('',(#20043),#7636,.F.); +#20043 = FACE_BOUND('',#20044,.T.); +#20044 = EDGE_LOOP('',(#20045,#20066,#20067,#20068)); +#20045 = ORIENTED_EDGE('',*,*,#20046,.T.); +#20046 = EDGE_CURVE('',#12987,#7509,#20047,.T.); +#20047 = SURFACE_CURVE('',#20048,(#20052,#20059),.PCURVE_S1.); +#20048 = LINE('',#20049,#20050); +#20049 = CARTESIAN_POINT('',(-25.55000000011,-64.60000000003,31.5)); +#20050 = VECTOR('',#20051,1.); +#20051 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#20052 = PCURVE('',#7636,#20053); +#20053 = DEFINITIONAL_REPRESENTATION('',(#20054),#20058); +#20054 = LINE('',#20055,#20056); +#20055 = CARTESIAN_POINT('',(0.449999999979,-4.875270381203E-14)); +#20056 = VECTOR('',#20057,1.); +#20057 = DIRECTION('',(-2.286638207901E-16,-1.)); +#20058 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20059 = PCURVE('',#7526,#20060); +#20060 = DEFINITIONAL_REPRESENTATION('',(#20061),#20065); +#20061 = LINE('',#20062,#20063); +#20062 = CARTESIAN_POINT('',(0.424264068711,-6.563482528381E-14)); +#20063 = VECTOR('',#20064,1.); +#20064 = DIRECTION('',(-1.397496474766E-15,-1.)); +#20065 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20066 = ORIENTED_EDGE('',*,*,#7622,.T.); +#20067 = ORIENTED_EDGE('',*,*,#19392,.T.); +#20068 = ORIENTED_EDGE('',*,*,#13016,.T.); +#20069 = ADVANCED_FACE('',(#20070),#7385,.F.); +#20070 = FACE_BOUND('',#20071,.T.); +#20071 = EDGE_LOOP('',(#20072,#20093,#20094,#20115)); +#20072 = ORIENTED_EDGE('',*,*,#20073,.T.); +#20073 = EDGE_CURVE('',#12887,#7286,#20074,.T.); +#20074 = SURFACE_CURVE('',#20075,(#20079,#20086),.PCURVE_S1.); +#20075 = LINE('',#20076,#20077); +#20076 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 25.949999999979)); +#20077 = VECTOR('',#20078,1.); +#20078 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#20079 = PCURVE('',#7385,#20080); +#20080 = DEFINITIONAL_REPRESENTATION('',(#20081),#20085); +#20081 = LINE('',#20082,#20083); +#20082 = CARTESIAN_POINT('',(14.449999999979,1.297594615557E-14)); +#20083 = VECTOR('',#20084,1.); +#20084 = DIRECTION('',(1.747694647186E-15,-1.)); +#20085 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20086 = PCURVE('',#7303,#20087); +#20087 = DEFINITIONAL_REPRESENTATION('',(#20088),#20092); +#20088 = LINE('',#20089,#20090); +#20089 = CARTESIAN_POINT('',(8.273149339912,6.203258733981E-15)); +#20090 = VECTOR('',#20091,1.); +#20091 = DIRECTION('',(-1.397496474766E-15,-1.)); +#20092 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20093 = ORIENTED_EDGE('',*,*,#7371,.T.); +#20094 = ORIENTED_EDGE('',*,*,#20095,.T.); +#20095 = EDGE_CURVE('',#7344,#12917,#20096,.T.); +#20096 = SURFACE_CURVE('',#20097,(#20101,#20108),.PCURVE_S1.); +#20097 = LINE('',#20098,#20099); +#20098 = CARTESIAN_POINT('',(-26.00000000009,-64.60000000003, + 22.949999999979)); +#20099 = VECTOR('',#20100,1.); +#20100 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#20101 = PCURVE('',#7385,#20102); +#20102 = DEFINITIONAL_REPRESENTATION('',(#20103),#20107); +#20103 = LINE('',#20104,#20105); +#20104 = CARTESIAN_POINT('',(11.449999999979,1.323232855549E-14)); +#20105 = VECTOR('',#20106,1.); +#20106 = DIRECTION('',(-1.747694647186E-15,1.)); +#20107 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20108 = PCURVE('',#7359,#20109); +#20109 = DEFINITIONAL_REPRESENTATION('',(#20110),#20114); +#20110 = LINE('',#20111,#20112); +#20111 = CARTESIAN_POINT('',(23.263813101024,2.96832437393E-14)); +#20112 = VECTOR('',#20113,1.); +#20113 = DIRECTION('',(-1.397496474766E-15,1.)); +#20114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20115 = ORIENTED_EDGE('',*,*,#12916,.T.); +#20116 = ADVANCED_FACE('',(#20117),#7554,.F.); +#20117 = FACE_BOUND('',#20118,.T.); +#20118 = EDGE_LOOP('',(#20119,#20140,#20141,#20162)); +#20119 = ORIENTED_EDGE('',*,*,#20120,.T.); +#20120 = EDGE_CURVE('',#18227,#7539,#20121,.T.); +#20121 = SURFACE_CURVE('',#20122,(#20126,#20133),.PCURVE_S1.); +#20122 = LINE('',#20123,#20124); +#20123 = CARTESIAN_POINT('',(-8.550000000118,-64.60000000005,11.5)); +#20124 = VECTOR('',#20125,1.); +#20125 = DIRECTION('',(-1.439293502184E-12,-1.,1.833155447161E-15)); +#20126 = PCURVE('',#7554,#20127); +#20127 = DEFINITIONAL_REPRESENTATION('',(#20128),#20132); +#20128 = LINE('',#20129,#20130); +#20129 = CARTESIAN_POINT('',(30.550000000049,3.337538620415E-14)); +#20130 = VECTOR('',#20131,1.); +#20131 = DIRECTION('',(2.286638207901E-16,-1.)); +#20132 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20133 = PCURVE('',#7582,#20134); +#20134 = DEFINITIONAL_REPRESENTATION('',(#20135),#20139); +#20135 = LINE('',#20136,#20137); +#20136 = CARTESIAN_POINT('',(7.071067811882,1.086278277817E-13)); +#20137 = VECTOR('',#20138,1.); +#20138 = DIRECTION('',(1.397496474766E-15,-1.)); +#20139 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20140 = ORIENTED_EDGE('',*,*,#7538,.T.); +#20141 = ORIENTED_EDGE('',*,*,#20142,.T.); +#20142 = EDGE_CURVE('',#7511,#18250,#20143,.T.); +#20143 = SURFACE_CURVE('',#20144,(#20148,#20155),.PCURVE_S1.); +#20144 = LINE('',#20145,#20146); +#20145 = CARTESIAN_POINT('',(-5.550000000118,-64.60000000006,11.5)); +#20146 = VECTOR('',#20147,1.); +#20147 = DIRECTION('',(1.439293502184E-12,1.,-1.833155447161E-15)); +#20148 = PCURVE('',#7554,#20149); +#20149 = DEFINITIONAL_REPRESENTATION('',(#20150),#20154); +#20150 = LINE('',#20151,#20152); +#20151 = CARTESIAN_POINT('',(27.550000000048,-4.058420570311E-14)); +#20152 = VECTOR('',#20153,1.); +#20153 = DIRECTION('',(-2.286638207901E-16,1.)); +#20154 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20155 = PCURVE('',#7526,#20156); +#20156 = DEFINITIONAL_REPRESENTATION('',(#20157),#20161); +#20157 = LINE('',#20158,#20159); +#20158 = CARTESIAN_POINT('',(28.708535316173,-8.803134973726E-14)); +#20159 = VECTOR('',#20160,1.); +#20160 = DIRECTION('',(1.397496474766E-15,1.)); +#20161 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20162 = ORIENTED_EDGE('',*,*,#18249,.T.); +#20163 = ADVANCED_FACE('',(#20164),#7919,.F.); +#20164 = FACE_BOUND('',#20165,.T.); +#20165 = EDGE_LOOP('',(#20166,#20167,#20168,#20169)); +#20166 = ORIENTED_EDGE('',*,*,#19157,.F.); +#20167 = ORIENTED_EDGE('',*,*,#18571,.T.); +#20168 = ORIENTED_EDGE('',*,*,#19561,.F.); +#20169 = ORIENTED_EDGE('',*,*,#7903,.F.); +#20170 = ADVANCED_FACE('',(#20171),#7696,.F.); +#20171 = FACE_BOUND('',#20172,.T.); +#20172 = EDGE_LOOP('',(#20173,#20174,#20175,#20176)); +#20173 = ORIENTED_EDGE('',*,*,#19110,.F.); +#20174 = ORIENTED_EDGE('',*,*,#18479,.T.); +#20175 = ORIENTED_EDGE('',*,*,#19605,.F.); +#20176 = ORIENTED_EDGE('',*,*,#7680,.F.); +#20177 = ADVANCED_FACE('',(#20178),#7445,.F.); +#20178 = FACE_BOUND('',#20179,.T.); +#20179 = EDGE_LOOP('',(#20180,#20181,#20182,#20183)); +#20180 = ORIENTED_EDGE('',*,*,#19063,.F.); +#20181 = ORIENTED_EDGE('',*,*,#18387,.T.); +#20182 = ORIENTED_EDGE('',*,*,#19649,.F.); +#20183 = ORIENTED_EDGE('',*,*,#7429,.F.); +#20184 = ADVANCED_FACE('',(#20185),#7303,.F.); +#20185 = FACE_BOUND('',#20186,.T.); +#20186 = EDGE_LOOP('',(#20187,#20188,#20189,#20190,#20191)); +#20187 = ORIENTED_EDGE('',*,*,#20073,.F.); +#20188 = ORIENTED_EDGE('',*,*,#12886,.T.); +#20189 = ORIENTED_EDGE('',*,*,#18204,.T.); +#20190 = ORIENTED_EDGE('',*,*,#19970,.F.); +#20191 = ORIENTED_EDGE('',*,*,#7285,.F.); +#20192 = ADVANCED_FACE('',(#20193),#7526,.F.); +#20193 = FACE_BOUND('',#20194,.T.); +#20194 = EDGE_LOOP('',(#20195,#20196,#20197,#20198,#20199)); +#20195 = ORIENTED_EDGE('',*,*,#20046,.F.); +#20196 = ORIENTED_EDGE('',*,*,#12986,.T.); +#20197 = ORIENTED_EDGE('',*,*,#18272,.T.); +#20198 = ORIENTED_EDGE('',*,*,#20142,.F.); +#20199 = ORIENTED_EDGE('',*,*,#7508,.F.); +#20200 = ADVANCED_FACE('',(#20201),#7777,.F.); +#20201 = FACE_BOUND('',#20202,.T.); +#20202 = EDGE_LOOP('',(#20203,#20204,#20205,#20206)); +#20203 = ORIENTED_EDGE('',*,*,#19345,.F.); +#20204 = ORIENTED_EDGE('',*,*,#18876,.T.); +#20205 = ORIENTED_EDGE('',*,*,#19945,.F.); +#20206 = ORIENTED_EDGE('',*,*,#7759,.F.); +#20207 = ADVANCED_FACE('',(#20208),#8028,.F.); +#20208 = FACE_BOUND('',#20209,.T.); +#20209 = EDGE_LOOP('',(#20210,#20211,#20212,#20213)); +#20210 = ORIENTED_EDGE('',*,*,#19298,.F.); +#20211 = ORIENTED_EDGE('',*,*,#18970,.T.); +#20212 = ORIENTED_EDGE('',*,*,#19851,.F.); +#20213 = ORIENTED_EDGE('',*,*,#8010,.F.); +#20214 = ADVANCED_FACE('',(#20215),#8256,.F.); +#20215 = FACE_BOUND('',#20216,.T.); +#20216 = EDGE_LOOP('',(#20217,#20218,#20219,#20220)); +#20217 = ORIENTED_EDGE('',*,*,#19251,.F.); +#20218 = ORIENTED_EDGE('',*,*,#18782,.T.); +#20219 = ORIENTED_EDGE('',*,*,#19776,.F.); +#20220 = ORIENTED_EDGE('',*,*,#8238,.F.); +#20221 = ADVANCED_FACE('',(#20222),#8170,.F.); +#20222 = FACE_BOUND('',#20223,.T.); +#20223 = EDGE_LOOP('',(#20224,#20225,#20226,#20227)); +#20224 = ORIENTED_EDGE('',*,*,#19204,.F.); +#20225 = ORIENTED_EDGE('',*,*,#18665,.T.); +#20226 = ORIENTED_EDGE('',*,*,#19729,.F.); +#20227 = ORIENTED_EDGE('',*,*,#8154,.F.); +#20228 = ADVANCED_FACE('',(#20229),#7217,.F.); +#20229 = FACE_BOUND('',#20230,.T.); +#20230 = EDGE_LOOP('',(#20231,#20232,#20233,#20234,#20235)); +#20231 = ORIENTED_EDGE('',*,*,#19464,.F.); +#20232 = ORIENTED_EDGE('',*,*,#12686,.T.); +#20233 = ORIENTED_EDGE('',*,*,#18068,.T.); +#20234 = ORIENTED_EDGE('',*,*,#19801,.F.); +#20235 = ORIENTED_EDGE('',*,*,#7199,.F.); +#20236 = ADVANCED_FACE('',(#20237),#7159,.F.); +#20237 = FACE_BOUND('',#20238,.T.); +#20238 = EDGE_LOOP('',(#20239,#20240,#20241,#20242,#20243)); +#20239 = ORIENTED_EDGE('',*,*,#19417,.F.); +#20240 = ORIENTED_EDGE('',*,*,#7143,.T.); +#20241 = ORIENTED_EDGE('',*,*,#19898,.F.); +#20242 = ORIENTED_EDGE('',*,*,#18090,.T.); +#20243 = ORIENTED_EDGE('',*,*,#12839,.T.); +#20244 = ADVANCED_FACE('',(#20245),#7103,.F.); +#20245 = FACE_BOUND('',#20246,.T.); +#20246 = EDGE_LOOP('',(#20247,#20248,#20249,#20250,#20251)); +#20247 = ORIENTED_EDGE('',*,*,#19439,.F.); +#20248 = ORIENTED_EDGE('',*,*,#12786,.T.); +#20249 = ORIENTED_EDGE('',*,*,#18136,.T.); +#20250 = ORIENTED_EDGE('',*,*,#19876,.F.); +#20251 = ORIENTED_EDGE('',*,*,#7085,.F.); +#20252 = ADVANCED_FACE('',(#20253),#7359,.F.); +#20253 = FACE_BOUND('',#20254,.T.); +#20254 = EDGE_LOOP('',(#20255,#20256,#20257,#20258,#20259)); +#20255 = ORIENTED_EDGE('',*,*,#20095,.F.); +#20256 = ORIENTED_EDGE('',*,*,#7343,.T.); +#20257 = ORIENTED_EDGE('',*,*,#19992,.F.); +#20258 = ORIENTED_EDGE('',*,*,#18158,.T.); +#20259 = ORIENTED_EDGE('',*,*,#12939,.T.); +#20260 = ADVANCED_FACE('',(#20261),#7582,.F.); +#20261 = FACE_BOUND('',#20262,.T.); +#20262 = EDGE_LOOP('',(#20263,#20264,#20265,#20266,#20267)); +#20263 = ORIENTED_EDGE('',*,*,#19370,.F.); +#20264 = ORIENTED_EDGE('',*,*,#7566,.T.); +#20265 = ORIENTED_EDGE('',*,*,#20120,.F.); +#20266 = ORIENTED_EDGE('',*,*,#18226,.T.); +#20267 = ORIENTED_EDGE('',*,*,#13062,.T.); +#20268 = ADVANCED_FACE('',(#20269),#7833,.F.); +#20269 = FACE_BOUND('',#20270,.T.); +#20270 = EDGE_LOOP('',(#20271,#20272,#20273,#20274)); +#20271 = ORIENTED_EDGE('',*,*,#19323,.F.); +#20272 = ORIENTED_EDGE('',*,*,#7817,.T.); +#20273 = ORIENTED_EDGE('',*,*,#19923,.F.); +#20274 = ORIENTED_EDGE('',*,*,#18830,.T.); +#20275 = ADVANCED_FACE('',(#20276),#8084,.F.); +#20276 = FACE_BOUND('',#20277,.T.); +#20277 = EDGE_LOOP('',(#20278,#20279,#20280,#20281)); +#20278 = ORIENTED_EDGE('',*,*,#19276,.F.); +#20279 = ORIENTED_EDGE('',*,*,#8068,.T.); +#20280 = ORIENTED_EDGE('',*,*,#19829,.F.); +#20281 = ORIENTED_EDGE('',*,*,#18924,.T.); +#20282 = ADVANCED_FACE('',(#20283),#8312,.F.); +#20283 = FACE_BOUND('',#20284,.T.); +#20284 = EDGE_LOOP('',(#20285,#20286,#20287,#20288)); +#20285 = ORIENTED_EDGE('',*,*,#19229,.F.); +#20286 = ORIENTED_EDGE('',*,*,#8296,.T.); +#20287 = ORIENTED_EDGE('',*,*,#19754,.F.); +#20288 = ORIENTED_EDGE('',*,*,#18736,.T.); +#20289 = ADVANCED_FACE('',(#20290),#8224,.F.); +#20290 = FACE_BOUND('',#20291,.T.); +#20291 = EDGE_LOOP('',(#20292,#20293,#20294,#20295)); +#20292 = ORIENTED_EDGE('',*,*,#19182,.F.); +#20293 = ORIENTED_EDGE('',*,*,#8210,.T.); +#20294 = ORIENTED_EDGE('',*,*,#19707,.F.); +#20295 = ORIENTED_EDGE('',*,*,#18617,.T.); +#20296 = ADVANCED_FACE('',(#20297),#7996,.F.); +#20297 = FACE_BOUND('',#20298,.T.); +#20298 = EDGE_LOOP('',(#20299,#20300,#20301,#20302)); +#20299 = ORIENTED_EDGE('',*,*,#19135,.F.); +#20300 = ORIENTED_EDGE('',*,*,#7982,.T.); +#20301 = ORIENTED_EDGE('',*,*,#19680,.F.); +#20302 = ORIENTED_EDGE('',*,*,#17974,.T.); +#20303 = ADVANCED_FACE('',(#20304),#7745,.F.); +#20304 = FACE_BOUND('',#20305,.T.); +#20305 = EDGE_LOOP('',(#20306,#20307,#20308,#20309)); +#20306 = ORIENTED_EDGE('',*,*,#19088,.F.); +#20307 = ORIENTED_EDGE('',*,*,#7731,.T.); +#20308 = ORIENTED_EDGE('',*,*,#19583,.F.); +#20309 = ORIENTED_EDGE('',*,*,#18525,.T.); +#20310 = ADVANCED_FACE('',(#20311),#7494,.F.); +#20311 = FACE_BOUND('',#20312,.T.); +#20312 = EDGE_LOOP('',(#20313,#20314,#20315,#20316)); +#20313 = ORIENTED_EDGE('',*,*,#19041,.F.); +#20314 = ORIENTED_EDGE('',*,*,#7480,.T.); +#20315 = ORIENTED_EDGE('',*,*,#19627,.F.); +#20316 = ORIENTED_EDGE('',*,*,#18433,.T.); +#20317 = ADVANCED_FACE('',(#20318),#7071,.F.); +#20318 = FACE_BOUND('',#20319,.T.); +#20319 = EDGE_LOOP('',(#20320,#20321,#20322,#20323)); +#20320 = ORIENTED_EDGE('',*,*,#18994,.F.); +#20321 = ORIENTED_EDGE('',*,*,#7057,.T.); +#20322 = ORIENTED_EDGE('',*,*,#19511,.F.); +#20323 = ORIENTED_EDGE('',*,*,#18341,.T.); +#20324 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#20328)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#20325,#20326,#20327)) +REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#20325 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#20326 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#20327 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#20328 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#20325, + 'distance_accuracy_value','confusion accuracy'); +#20329 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#20330,#20332); +#20330 = ( REPRESENTATION_RELATIONSHIP('','',#2597,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#20331) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#20331 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#20332 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item', + #20333); +#20333 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Desk','',#5,#2592,$); +#20334 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#2594)); +#20335 = SHAPE_DEFINITION_REPRESENTATION(#20336,#20342); +#20336 = PRODUCT_DEFINITION_SHAPE('','',#20337); +#20337 = PRODUCT_DEFINITION('design','',#20338,#20341); +#20338 = PRODUCT_DEFINITION_FORMATION('','',#20339); +#20339 = PRODUCT('Chair','Chair','',(#20340)); +#20340 = PRODUCT_CONTEXT('',#2,'mechanical'); +#20341 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#20342 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#20343),#26683); +#20343 = MANIFOLD_SOLID_BREP('',#20344); +#20344 = CLOSED_SHELL('',(#20345,#20471,#20609,#20718,#20832,#20941, + #21055,#21151,#21155,#21246,#21250,#21346,#21350,#21441,#21445, + #21565,#21760,#21916,#22069,#22116,#22143,#22387,#22616,#22663, + #22710,#22719,#22726,#22735,#22970,#23069,#23141,#23221,#23322, + #23433,#23504,#23551,#23624,#23696,#23805,#23856,#23886,#23935, + #24050,#24150,#24197,#24224,#24295,#24502,#24555,#24790,#24889, + #24965,#25045,#25309,#25387,#25498,#25569,#25692,#25719,#25747, + #25774,#25851,#25902,#25912,#25961,#25988,#26098,#26198,#26245, + #26272,#26343,#26396,#26467,#26516,#26543,#26630,#26665,#26672)); +#20345 = ADVANCED_FACE('',(#20346),#20361,.T.); +#20346 = FACE_BOUND('',#20347,.T.); +#20347 = EDGE_LOOP('',(#20348,#20384,#20412,#20445)); +#20348 = ORIENTED_EDGE('',*,*,#20349,.F.); +#20349 = EDGE_CURVE('',#20350,#20352,#20354,.T.); +#20350 = VERTEX_POINT('',#20351); +#20351 = CARTESIAN_POINT('',(-34.7,1.999999999997,8.5)); +#20352 = VERTEX_POINT('',#20353); +#20353 = CARTESIAN_POINT('',(-36.7,1.999999999996,10.5)); +#20354 = SURFACE_CURVE('',#20355,(#20360,#20372),.PCURVE_S1.); +#20355 = CIRCLE('',#20356,2.); +#20356 = AXIS2_PLACEMENT_3D('',#20357,#20358,#20359); +#20357 = CARTESIAN_POINT('',(-34.7,1.999999999996,10.5)); +#20358 = DIRECTION('',(-3.847746958534E-14,1.,-8.553453836232E-16)); +#20359 = DIRECTION('',(-0.707106781187,-2.781250018771E-14, + -0.707106781187)); +#20360 = PCURVE('',#20361,#20366); +#20361 = CYLINDRICAL_SURFACE('',#20362,2.); +#20362 = AXIS2_PLACEMENT_3D('',#20363,#20364,#20365); +#20363 = CARTESIAN_POINT('',(-34.7,-1.499999999997,10.5)); +#20364 = DIRECTION('',(-3.819497970755E-14,-1.,9.71445146547E-16)); +#20365 = DIRECTION('',(-0.707106781187,2.632101370782E-14, + -0.707106781187)); +#20366 = DEFINITIONAL_REPRESENTATION('',(#20367),#20371); +#20367 = LINE('',#20368,#20369); +#20368 = CARTESIAN_POINT('',(6.28318530718,-3.499999999994)); +#20369 = VECTOR('',#20370,1.); +#20370 = DIRECTION('',(-1.,9.781972620323E-14)); +#20371 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20372 = PCURVE('',#20373,#20378); +#20373 = PLANE('',#20374); +#20374 = AXIS2_PLACEMENT_3D('',#20375,#20376,#20377); +#20375 = CARTESIAN_POINT('',(-38.7,1.999999999996,19.8)); +#20376 = DIRECTION('',(-3.847746958534E-14,1.,-8.553453836232E-16)); +#20377 = DIRECTION('',(1.,3.847746958534E-14,-6.542148133408E-29)); +#20378 = DEFINITIONAL_REPRESENTATION('',(#20379),#20383); +#20379 = CIRCLE('',#20380,2.); +#20380 = AXIS2_PLACEMENT_2D('',#20381,#20382); +#20381 = CARTESIAN_POINT('',(4.,9.3)); +#20382 = DIRECTION('',(-0.707106781187,0.707106781187)); +#20383 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20384 = ORIENTED_EDGE('',*,*,#20385,.T.); +#20385 = EDGE_CURVE('',#20350,#20386,#20388,.T.); +#20386 = VERTEX_POINT('',#20387); +#20387 = CARTESIAN_POINT('',(-34.7,-1.999999999997,8.5)); +#20388 = SURFACE_CURVE('',#20389,(#20393,#20400),.PCURVE_S1.); +#20389 = LINE('',#20390,#20391); +#20390 = CARTESIAN_POINT('',(-34.7,-1.499999999997,8.5)); +#20391 = VECTOR('',#20392,1.); +#20392 = DIRECTION('',(-3.819497970755E-14,-1.,9.71445146547E-16)); +#20393 = PCURVE('',#20361,#20394); +#20394 = DEFINITIONAL_REPRESENTATION('',(#20395),#20399); +#20395 = LINE('',#20396,#20397); +#20396 = CARTESIAN_POINT('',(0.785398163397,-1.7763568394E-15)); +#20397 = VECTOR('',#20398,1.); +#20398 = DIRECTION('',(6.383782391605E-16,1.)); +#20399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20400 = PCURVE('',#20401,#20406); +#20401 = PLANE('',#20402); +#20402 = AXIS2_PLACEMENT_3D('',#20403,#20404,#20405); +#20403 = CARTESIAN_POINT('',(-29.84999999997,-0.999999999998,8.5)); +#20404 = DIRECTION('',(3.710432765936E-29,9.71445146547E-16,1.)); +#20405 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#20406 = DEFINITIONAL_REPRESENTATION('',(#20407),#20411); +#20407 = LINE('',#20408,#20409); +#20408 = CARTESIAN_POINT('',(-4.850000000021,-0.499999999999)); +#20409 = VECTOR('',#20410,1.); +#20410 = DIRECTION('',(-9.860761315263E-32,-1.)); +#20411 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20412 = ORIENTED_EDGE('',*,*,#20413,.F.); +#20413 = EDGE_CURVE('',#20414,#20386,#20416,.T.); +#20414 = VERTEX_POINT('',#20415); +#20415 = CARTESIAN_POINT('',(-36.7,-1.999999999996,10.5)); +#20416 = SURFACE_CURVE('',#20417,(#20422,#20429),.PCURVE_S1.); +#20417 = CIRCLE('',#20418,2.); +#20418 = AXIS2_PLACEMENT_3D('',#20419,#20420,#20421); +#20419 = CARTESIAN_POINT('',(-34.7,-1.999999999996,10.5)); +#20420 = DIRECTION('',(-3.847253546371E-14,-1.,8.553453836232E-16)); +#20421 = DIRECTION('',(-0.707106781187,2.659937019481E-14, + -0.707106781187)); +#20422 = PCURVE('',#20361,#20423); +#20423 = DEFINITIONAL_REPRESENTATION('',(#20424),#20428); +#20424 = LINE('',#20425,#20426); +#20425 = CARTESIAN_POINT('',(-6.28318530718,0.499999999999)); +#20426 = VECTOR('',#20427,1.); +#20427 = DIRECTION('',(1.,2.827159716856E-16)); +#20428 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20429 = PCURVE('',#20430,#20435); +#20430 = PLANE('',#20431); +#20431 = AXIS2_PLACEMENT_3D('',#20432,#20433,#20434); +#20432 = CARTESIAN_POINT('',(-38.7,-1.999999999996,19.8)); +#20433 = DIRECTION('',(3.847253546371E-14,1.,-8.553453836232E-16)); +#20434 = DIRECTION('',(1.,-3.847253546371E-14,3.973502544019E-31)); +#20435 = DEFINITIONAL_REPRESENTATION('',(#20436),#20444); +#20436 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20437,#20438,#20439,#20440 + ,#20441,#20442,#20443),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20437 = CARTESIAN_POINT('',(2.585786437627,10.714213562373)); +#20438 = CARTESIAN_POINT('',(5.03527618041,13.163703305156)); +#20439 = CARTESIAN_POINT('',(5.931851652578,9.817638090205)); +#20440 = CARTESIAN_POINT('',(6.828427124746,6.471572875254)); +#20441 = CARTESIAN_POINT('',(3.482361909795,7.368148347422)); +#20442 = CARTESIAN_POINT('',(0.136296694844,8.26472381959)); +#20443 = CARTESIAN_POINT('',(2.585786437627,10.714213562373)); +#20444 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20445 = ORIENTED_EDGE('',*,*,#20446,.T.); +#20446 = EDGE_CURVE('',#20414,#20352,#20447,.T.); +#20447 = SURFACE_CURVE('',#20448,(#20452,#20459),.PCURVE_S1.); +#20448 = LINE('',#20449,#20450); +#20449 = CARTESIAN_POINT('',(-36.7,-1.499999999997,10.5)); +#20450 = VECTOR('',#20451,1.); +#20451 = DIRECTION('',(3.819497970755E-14,1.,-9.71445146547E-16)); +#20452 = PCURVE('',#20361,#20453); +#20453 = DEFINITIONAL_REPRESENTATION('',(#20454),#20458); +#20454 = LINE('',#20455,#20456); +#20455 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#20456 = VECTOR('',#20457,1.); +#20457 = DIRECTION('',(0.,-1.)); +#20458 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20459 = PCURVE('',#20460,#20465); +#20460 = PLANE('',#20461); +#20461 = AXIS2_PLACEMENT_3D('',#20462,#20463,#20464); +#20462 = CARTESIAN_POINT('',(-36.7,-1.999999999996,19.8)); +#20463 = DIRECTION('',(-1.,3.819497970755E-14,2.23364318625E-44)); +#20464 = DIRECTION('',(3.819497970755E-14,1.,-8.553453836232E-16)); +#20465 = DEFINITIONAL_REPRESENTATION('',(#20466),#20470); +#20466 = LINE('',#20467,#20468); +#20467 = CARTESIAN_POINT('',(0.499999999999,9.3)); +#20468 = VECTOR('',#20469,1.); +#20469 = DIRECTION('',(1.,1.160997629238E-16)); +#20470 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20471 = ADVANCED_FACE('',(#20472),#20401,.F.); +#20472 = FACE_BOUND('',#20473,.T.); +#20473 = EDGE_LOOP('',(#20474,#20475,#20498,#20531,#20559,#20588)); +#20474 = ORIENTED_EDGE('',*,*,#20385,.F.); +#20475 = ORIENTED_EDGE('',*,*,#20476,.T.); +#20476 = EDGE_CURVE('',#20350,#20477,#20479,.T.); +#20477 = VERTEX_POINT('',#20478); +#20478 = CARTESIAN_POINT('',(-23.74999999995,2.,8.5)); +#20479 = SURFACE_CURVE('',#20480,(#20484,#20491),.PCURVE_S1.); +#20480 = LINE('',#20481,#20482); +#20481 = CARTESIAN_POINT('',(-22.99999999995,2.,8.5)); +#20482 = VECTOR('',#20483,1.); +#20483 = DIRECTION('',(1.,2.731701079818E-13,-2.346038366209E-28)); +#20484 = PCURVE('',#20401,#20485); +#20485 = DEFINITIONAL_REPRESENTATION('',(#20486),#20490); +#20486 = LINE('',#20487,#20488); +#20487 = CARTESIAN_POINT('',(6.850000000021,2.999999999998)); +#20488 = VECTOR('',#20489,1.); +#20489 = DIRECTION('',(1.,3.113650876893E-13)); +#20490 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20491 = PCURVE('',#20373,#20492); +#20492 = DEFINITIONAL_REPRESENTATION('',(#20493),#20497); +#20493 = LINE('',#20494,#20495); +#20494 = CARTESIAN_POINT('',(15.700000000043,11.3)); +#20495 = VECTOR('',#20496,1.); +#20496 = DIRECTION('',(1.,-3.156090953595E-29)); +#20497 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20498 = ORIENTED_EDGE('',*,*,#20499,.F.); +#20499 = EDGE_CURVE('',#20500,#20477,#20502,.T.); +#20500 = VERTEX_POINT('',#20501); +#20501 = CARTESIAN_POINT('',(-22.99999999995,2.749999999997,8.5)); +#20502 = SURFACE_CURVE('',#20503,(#20508,#20519),.PCURVE_S1.); +#20503 = CIRCLE('',#20504,0.75); +#20504 = AXIS2_PLACEMENT_3D('',#20505,#20506,#20507); +#20505 = CARTESIAN_POINT('',(-23.74999999995,2.749999999997,8.5)); +#20506 = DIRECTION('',(-3.711593981442E-29,-7.392456206993E-16,-1.)); +#20507 = DIRECTION('',(0.707106781187,-0.707106781186,5.227255913587E-16 + )); +#20508 = PCURVE('',#20401,#20509); +#20509 = DEFINITIONAL_REPRESENTATION('',(#20510),#20518); +#20510 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20511,#20512,#20513,#20514 + ,#20515,#20516,#20517),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20511 = CARTESIAN_POINT('',(6.630330085909,3.219669914105)); +#20512 = CARTESIAN_POINT('',(5.711771432366,2.301111260561)); +#20513 = CARTESIAN_POINT('',(5.375555630303,3.555885716168)); +#20514 = CARTESIAN_POINT('',(5.039339828239,4.810660171775)); +#20515 = CARTESIAN_POINT('',(6.294114283846,4.474444369712)); +#20516 = CARTESIAN_POINT('',(7.548888739453,4.13822856765)); +#20517 = CARTESIAN_POINT('',(6.630330085909,3.219669914105)); +#20518 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20519 = PCURVE('',#20520,#20525); +#20520 = CYLINDRICAL_SURFACE('',#20521,0.75); +#20521 = AXIS2_PLACEMENT_3D('',#20522,#20523,#20524); +#20522 = CARTESIAN_POINT('',(-23.74999999995,2.749999999997,19.8)); +#20523 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#20524 = DIRECTION('',(0.707106781187,-0.707106781186,6.048205210163E-16 + )); +#20525 = DEFINITIONAL_REPRESENTATION('',(#20526),#20530); +#20526 = LINE('',#20527,#20528); +#20527 = CARTESIAN_POINT('',(-6.28318530718,11.3)); +#20528 = VECTOR('',#20529,1.); +#20529 = DIRECTION('',(1.,0.)); +#20530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20531 = ORIENTED_EDGE('',*,*,#20532,.F.); +#20532 = EDGE_CURVE('',#20533,#20500,#20535,.T.); +#20533 = VERTEX_POINT('',#20534); +#20534 = CARTESIAN_POINT('',(-22.99999999995,-2.749999999997,8.5)); +#20535 = SURFACE_CURVE('',#20536,(#20540,#20547),.PCURVE_S1.); +#20536 = LINE('',#20537,#20538); +#20537 = CARTESIAN_POINT('',(-22.99999999995,-0.500000000002,8.5)); +#20538 = VECTOR('',#20539,1.); +#20539 = DIRECTION('',(7.19718024527E-13,1.,-9.71445146547E-16)); +#20540 = PCURVE('',#20401,#20541); +#20541 = DEFINITIONAL_REPRESENTATION('',(#20542),#20546); +#20542 = LINE('',#20543,#20544); +#20543 = CARTESIAN_POINT('',(6.850000000021,0.499999999997)); +#20544 = VECTOR('',#20545,1.); +#20545 = DIRECTION('',(6.815230448195E-13,1.)); +#20546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20547 = PCURVE('',#20548,#20553); +#20548 = PLANE('',#20549); +#20549 = AXIS2_PLACEMENT_3D('',#20550,#20551,#20552); +#20550 = CARTESIAN_POINT('',(-22.99999999995,8.06185230374E-15,19.8)); +#20551 = DIRECTION('',(1.,-7.19718024527E-13,5.829375902191E-28)); +#20552 = DIRECTION('',(-7.19718024527E-13,-1.,8.553453836232E-16)); +#20553 = DEFINITIONAL_REPRESENTATION('',(#20554),#20558); +#20554 = LINE('',#20555,#20556); +#20555 = CARTESIAN_POINT('',(0.500000000002,11.3)); +#20556 = VECTOR('',#20557,1.); +#20557 = DIRECTION('',(-1.,1.160997629238E-16)); +#20558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20559 = ORIENTED_EDGE('',*,*,#20560,.T.); +#20560 = EDGE_CURVE('',#20533,#20561,#20563,.T.); +#20561 = VERTEX_POINT('',#20562); +#20562 = CARTESIAN_POINT('',(-23.74999999995,-2.,8.5)); +#20563 = SURFACE_CURVE('',#20564,(#20569,#20576),.PCURVE_S1.); +#20564 = CIRCLE('',#20565,0.75); +#20565 = AXIS2_PLACEMENT_3D('',#20566,#20567,#20568); +#20566 = CARTESIAN_POINT('',(-23.74999999995,-2.749999999997,8.5)); +#20567 = DIRECTION('',(3.708374174626E-29,9.71445146547E-16,1.)); +#20568 = DIRECTION('',(0.707106781187,0.707106781186,-6.869154506739E-16 + )); +#20569 = PCURVE('',#20401,#20570); +#20570 = DEFINITIONAL_REPRESENTATION('',(#20571),#20575); +#20571 = CIRCLE('',#20572,0.75); +#20572 = AXIS2_PLACEMENT_2D('',#20573,#20574); +#20573 = CARTESIAN_POINT('',(6.100000000019,-1.749999999998)); +#20574 = DIRECTION('',(0.707106781187,0.707106781186)); +#20575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20576 = PCURVE('',#20577,#20582); +#20577 = CYLINDRICAL_SURFACE('',#20578,0.75); +#20578 = AXIS2_PLACEMENT_3D('',#20579,#20580,#20581); +#20579 = CARTESIAN_POINT('',(-23.74999999995,-2.749999999997,19.8)); +#20580 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#20581 = DIRECTION('',(0.707106781187,0.707106781186,-6.048205210164E-16 + )); +#20582 = DEFINITIONAL_REPRESENTATION('',(#20583),#20587); +#20583 = LINE('',#20584,#20585); +#20584 = CARTESIAN_POINT('',(-6.28318530718,-11.3)); +#20585 = VECTOR('',#20586,1.); +#20586 = DIRECTION('',(1.,0.)); +#20587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20588 = ORIENTED_EDGE('',*,*,#20589,.F.); +#20589 = EDGE_CURVE('',#20386,#20561,#20590,.T.); +#20590 = SURFACE_CURVE('',#20591,(#20595,#20602),.PCURVE_S1.); +#20591 = LINE('',#20592,#20593); +#20592 = CARTESIAN_POINT('',(-22.99999999995,-2.,8.5)); +#20593 = VECTOR('',#20594,1.); +#20594 = DIRECTION('',(1.,-2.731651738601E-13,2.327015246131E-28)); +#20595 = PCURVE('',#20401,#20596); +#20596 = DEFINITIONAL_REPRESENTATION('',(#20597),#20601); +#20597 = LINE('',#20598,#20599); +#20598 = CARTESIAN_POINT('',(6.850000000021,-1.000000000002)); +#20599 = VECTOR('',#20600,1.); +#20600 = DIRECTION('',(1.,-2.349701941526E-13)); +#20601 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20602 = PCURVE('',#20430,#20603); +#20603 = DEFINITIONAL_REPRESENTATION('',(#20604),#20608); +#20604 = LINE('',#20605,#20606); +#20605 = CARTESIAN_POINT('',(15.700000000043,11.3)); +#20606 = VECTOR('',#20607,1.); +#20607 = DIRECTION('',(1.,-3.156090953595E-29)); +#20608 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20609 = ADVANCED_FACE('',(#20610),#20624,.F.); +#20610 = FACE_BOUND('',#20611,.F.); +#20611 = EDGE_LOOP('',(#20612,#20642,#20695,#20696)); +#20612 = ORIENTED_EDGE('',*,*,#20613,.T.); +#20613 = EDGE_CURVE('',#20614,#20616,#20618,.T.); +#20614 = VERTEX_POINT('',#20615); +#20615 = CARTESIAN_POINT('',(-38.04999999998,1.999999999996,7.)); +#20616 = VERTEX_POINT('',#20617); +#20617 = CARTESIAN_POINT('',(-38.04999999998,9.864000000013,7.)); +#20618 = SEAM_CURVE('',#20619,(#20623,#20635),.PCURVE_S1.); +#20619 = LINE('',#20620,#20621); +#20620 = CARTESIAN_POINT('',(-38.04999999998,3.825592440696E-12,7.)); +#20621 = VECTOR('',#20622,1.); +#20622 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#20623 = PCURVE('',#20624,#20629); +#20624 = CYLINDRICAL_SURFACE('',#20625,1.05); +#20625 = AXIS2_PLACEMENT_3D('',#20626,#20627,#20628); +#20626 = CARTESIAN_POINT('',(-36.99999999998,3.785487712003E-12,7.)); +#20627 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#20628 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#20629 = DEFINITIONAL_REPRESENTATION('',(#20630),#20634); +#20630 = LINE('',#20631,#20632); +#20631 = CARTESIAN_POINT('',(9.424777960769,0.)); +#20632 = VECTOR('',#20633,1.); +#20633 = DIRECTION('',(0.,1.)); +#20634 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20635 = PCURVE('',#20624,#20636); +#20636 = DEFINITIONAL_REPRESENTATION('',(#20637),#20641); +#20637 = LINE('',#20638,#20639); +#20638 = CARTESIAN_POINT('',(3.14159265359,0.)); +#20639 = VECTOR('',#20640,1.); +#20640 = DIRECTION('',(0.,1.)); +#20641 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20642 = ORIENTED_EDGE('',*,*,#20643,.T.); +#20643 = EDGE_CURVE('',#20616,#20616,#20644,.T.); +#20644 = SURFACE_CURVE('',#20645,(#20650,#20679),.PCURVE_S1.); +#20645 = ELLIPSE('',#20646,1.140015789364,1.05); +#20646 = AXIS2_PLACEMENT_3D('',#20647,#20648,#20649); +#20647 = CARTESIAN_POINT('',(-36.99999999998,9.420000000013,7.)); +#20648 = DIRECTION('',(-0.38946828995,-0.921039874882,5.530547345347E-16 + )); +#20649 = DIRECTION('',(0.921039874882,-0.38946828995,-4.130940360867E-32 + )); +#20650 = PCURVE('',#20624,#20651); +#20651 = DEFINITIONAL_REPRESENTATION('',(#20652),#20678); +#20652 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#20653,#20654,#20655,#20656, + #20657,#20658,#20659,#20660,#20661,#20662,#20663,#20664,#20665, + #20666,#20667,#20668,#20669,#20670,#20671,#20672,#20673,#20674, + #20675,#20676,#20677),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(3.14159265359,3.427191985734,3.712791317879 + ,3.998390650023,4.283989982168,4.569589314312,4.855188646457, + 5.140787978601,5.426387310746,5.711986642891,5.997585975035, + 6.28318530718,6.568784639324,6.854383971469,7.139983303613, + 7.425582635758,7.711181967902,7.996781300047,8.282380632191, + 8.567979964336,8.85357929648,9.139178628625,9.424777960769), + .QUASI_UNIFORM_KNOTS.); +#20653 = CARTESIAN_POINT('',(9.424777960769,9.864000000009)); +#20654 = CARTESIAN_POINT('',(9.329578183388,9.864229725547)); +#20655 = CARTESIAN_POINT('',(9.139178628625,9.851739194176)); +#20656 = CARTESIAN_POINT('',(8.85357929648,9.798657513826)); +#20657 = CARTESIAN_POINT('',(8.567979964336,9.714730162036)); +#20658 = CARTESIAN_POINT('',(8.282380632191,9.606970833313)); +#20659 = CARTESIAN_POINT('',(7.996781300047,9.484052099401)); +#20660 = CARTESIAN_POINT('',(7.711181967902,9.355947498295)); +#20661 = CARTESIAN_POINT('',(7.425582635758,9.233031178312)); +#20662 = CARTESIAN_POINT('',(7.139983303613,9.125262193874)); +#20663 = CARTESIAN_POINT('',(6.854383971469,9.041371051013)); +#20664 = CARTESIAN_POINT('',(6.568784639324,8.988154190662)); +#20665 = CARTESIAN_POINT('',(6.28318530718,8.969922904682)); +#20666 = CARTESIAN_POINT('',(5.997585975035,8.988154190662)); +#20667 = CARTESIAN_POINT('',(5.711986642891,9.041371051013)); +#20668 = CARTESIAN_POINT('',(5.426387310746,9.125262193874)); +#20669 = CARTESIAN_POINT('',(5.140787978601,9.233031178312)); +#20670 = CARTESIAN_POINT('',(4.855188646457,9.355947498295)); +#20671 = CARTESIAN_POINT('',(4.569589314312,9.484052099401)); +#20672 = CARTESIAN_POINT('',(4.283989982168,9.606970833313)); +#20673 = CARTESIAN_POINT('',(3.998390650023,9.714730162036)); +#20674 = CARTESIAN_POINT('',(3.712791317879,9.798657513826)); +#20675 = CARTESIAN_POINT('',(3.427191985734,9.851739194176)); +#20676 = CARTESIAN_POINT('',(3.236792430971,9.864229725547)); +#20677 = CARTESIAN_POINT('',(3.14159265359,9.864000000009)); +#20678 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20679 = PCURVE('',#20680,#20685); +#20680 = PLANE('',#20681); +#20681 = AXIS2_PLACEMENT_3D('',#20682,#20683,#20684); +#20682 = CARTESIAN_POINT('',(-22.99999999995,3.5,4.5)); +#20683 = DIRECTION('',(0.38946828995,0.921039874882,-5.530547345347E-16) + ); +#20684 = DIRECTION('',(-0.921039874882,0.38946828995,-2.805518877052E-16 + )); +#20685 = DEFINITIONAL_REPRESENTATION('',(#20686),#20694); +#20686 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20687,#20688,#20689,#20690 + ,#20691,#20692,#20693),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20687 = CARTESIAN_POINT('',(14.060194735519,2.5)); +#20688 = CARTESIAN_POINT('',(14.060194735519,4.318653347947)); +#20689 = CARTESIAN_POINT('',(15.770218419566,3.409326673974)); +#20690 = CARTESIAN_POINT('',(17.480242103612,2.5)); +#20691 = CARTESIAN_POINT('',(15.770218419566,1.590673326026)); +#20692 = CARTESIAN_POINT('',(14.060194735519,0.681346652053)); +#20693 = CARTESIAN_POINT('',(14.060194735519,2.5)); +#20694 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20695 = ORIENTED_EDGE('',*,*,#20613,.F.); +#20696 = ORIENTED_EDGE('',*,*,#20697,.T.); +#20697 = EDGE_CURVE('',#20614,#20614,#20698,.T.); +#20698 = SURFACE_CURVE('',#20699,(#20704,#20711),.PCURVE_S1.); +#20699 = CIRCLE('',#20700,1.05); +#20700 = AXIS2_PLACEMENT_3D('',#20701,#20702,#20703); +#20701 = CARTESIAN_POINT('',(-36.99999999998,1.999999999996,7.)); +#20702 = DIRECTION('',(-3.847746958534E-14,1.,-8.553453836232E-16)); +#20703 = DIRECTION('',(1.,3.847746958534E-14,-6.558142555375E-29)); +#20704 = PCURVE('',#20624,#20705); +#20705 = DEFINITIONAL_REPRESENTATION('',(#20706),#20710); +#20706 = LINE('',#20707,#20708); +#20707 = CARTESIAN_POINT('',(0.,1.999999999992)); +#20708 = VECTOR('',#20709,1.); +#20709 = DIRECTION('',(1.,0.)); +#20710 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20711 = PCURVE('',#20373,#20712); +#20712 = DEFINITIONAL_REPRESENTATION('',(#20713),#20717); +#20713 = CIRCLE('',#20714,1.05); +#20714 = AXIS2_PLACEMENT_2D('',#20715,#20716); +#20715 = CARTESIAN_POINT('',(1.70000000002,12.8)); +#20716 = DIRECTION('',(1.,1.599442196756E-31)); +#20717 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20718 = ADVANCED_FACE('',(#20719),#20733,.F.); +#20719 = FACE_BOUND('',#20720,.F.); +#20720 = EDGE_LOOP('',(#20721,#20751,#20778,#20779)); +#20721 = ORIENTED_EDGE('',*,*,#20722,.T.); +#20722 = EDGE_CURVE('',#20723,#20725,#20727,.T.); +#20723 = VERTEX_POINT('',#20724); +#20724 = CARTESIAN_POINT('',(-38.04999999997,21.864000000011,7.)); +#20725 = VERTEX_POINT('',#20726); +#20726 = CARTESIAN_POINT('',(-38.04999999997,30.299999999998,7.)); +#20727 = SEAM_CURVE('',#20728,(#20732,#20744),.PCURVE_S1.); +#20728 = LINE('',#20729,#20730); +#20729 = CARTESIAN_POINT('',(-38.04999999998,3.825592440696E-12,7.)); +#20730 = VECTOR('',#20731,1.); +#20731 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#20732 = PCURVE('',#20733,#20738); +#20733 = CYLINDRICAL_SURFACE('',#20734,1.05); +#20734 = AXIS2_PLACEMENT_3D('',#20735,#20736,#20737); +#20735 = CARTESIAN_POINT('',(-36.99999999998,3.785487712003E-12,7.)); +#20736 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#20737 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#20738 = DEFINITIONAL_REPRESENTATION('',(#20739),#20743); +#20739 = LINE('',#20740,#20741); +#20740 = CARTESIAN_POINT('',(9.424777960769,0.)); +#20741 = VECTOR('',#20742,1.); +#20742 = DIRECTION('',(0.,1.)); +#20743 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20744 = PCURVE('',#20733,#20745); +#20745 = DEFINITIONAL_REPRESENTATION('',(#20746),#20750); +#20746 = LINE('',#20747,#20748); +#20747 = CARTESIAN_POINT('',(3.14159265359,0.)); +#20748 = VECTOR('',#20749,1.); +#20749 = DIRECTION('',(0.,1.)); +#20750 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20751 = ORIENTED_EDGE('',*,*,#20752,.T.); +#20752 = EDGE_CURVE('',#20725,#20725,#20753,.T.); +#20753 = SURFACE_CURVE('',#20754,(#20759,#20766),.PCURVE_S1.); +#20754 = CIRCLE('',#20755,1.05); +#20755 = AXIS2_PLACEMENT_3D('',#20756,#20757,#20758); +#20756 = CARTESIAN_POINT('',(-36.99999999997,30.299999999998,7.)); +#20757 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#20758 = DIRECTION('',(1.,-7.556212847502E-13,6.136472781081E-28)); +#20759 = PCURVE('',#20733,#20760); +#20760 = DEFINITIONAL_REPRESENTATION('',(#20761),#20765); +#20761 = LINE('',#20762,#20763); +#20762 = CARTESIAN_POINT('',(12.566370614359,30.299999999995)); +#20763 = VECTOR('',#20764,1.); +#20764 = DIRECTION('',(-1.,0.)); +#20765 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20766 = PCURVE('',#20767,#20772); +#20767 = PLANE('',#20768); +#20768 = AXIS2_PLACEMENT_3D('',#20769,#20770,#20771); +#20769 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,19.8)); +#20770 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#20771 = DIRECTION('',(-1.,7.556212847502E-13,-6.138072223278E-28)); +#20772 = DEFINITIONAL_REPRESENTATION('',(#20773),#20777); +#20773 = CIRCLE('',#20774,1.05); +#20774 = AXIS2_PLACEMENT_2D('',#20775,#20776); +#20775 = CARTESIAN_POINT('',(14.,12.8)); +#20776 = DIRECTION('',(-1.,1.599442196757E-31)); +#20777 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20778 = ORIENTED_EDGE('',*,*,#20722,.F.); +#20779 = ORIENTED_EDGE('',*,*,#20780,.T.); +#20780 = EDGE_CURVE('',#20723,#20723,#20781,.T.); +#20781 = SURFACE_CURVE('',#20782,(#20787,#20816),.PCURVE_S1.); +#20782 = ELLIPSE('',#20783,1.140015789364,1.05); +#20783 = AXIS2_PLACEMENT_3D('',#20784,#20785,#20786); +#20784 = CARTESIAN_POINT('',(-36.99999999997,21.42000000001,7.)); +#20785 = DIRECTION('',(0.38946828995,0.921039874882,-5.530547345347E-16) + ); +#20786 = DIRECTION('',(0.921039874882,-0.38946828995,4.887214099278E-31) + ); +#20787 = PCURVE('',#20733,#20788); +#20788 = DEFINITIONAL_REPRESENTATION('',(#20789),#20815); +#20789 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#20790,#20791,#20792,#20793, + #20794,#20795,#20796,#20797,#20798,#20799,#20800,#20801,#20802, + #20803,#20804,#20805,#20806,#20807,#20808,#20809,#20810,#20811, + #20812,#20813,#20814),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(3.14159265359,3.427191985734,3.712791317879 + ,3.998390650023,4.283989982168,4.569589314312,4.855188646457, + 5.140787978601,5.426387310746,5.711986642891,5.997585975035, + 6.28318530718,6.568784639324,6.854383971469,7.139983303613, + 7.425582635758,7.711181967902,7.996781300047,8.282380632191, + 8.567979964336,8.85357929648,9.139178628625,9.424777960769), + .QUASI_UNIFORM_KNOTS.); +#20790 = CARTESIAN_POINT('',(3.14159265359,21.864000000007)); +#20791 = CARTESIAN_POINT('',(3.236792430971,21.864229725544)); +#20792 = CARTESIAN_POINT('',(3.427191985734,21.851739194174)); +#20793 = CARTESIAN_POINT('',(3.712791317879,21.798657513824)); +#20794 = CARTESIAN_POINT('',(3.998390650023,21.714730162034)); +#20795 = CARTESIAN_POINT('',(4.283989982168,21.606970833311)); +#20796 = CARTESIAN_POINT('',(4.569589314312,21.484052099399)); +#20797 = CARTESIAN_POINT('',(4.855188646457,21.355947498293)); +#20798 = CARTESIAN_POINT('',(5.140787978601,21.233031178309)); +#20799 = CARTESIAN_POINT('',(5.426387310746,21.125262193872)); +#20800 = CARTESIAN_POINT('',(5.711986642891,21.041371051011)); +#20801 = CARTESIAN_POINT('',(5.997585975035,20.98815419066)); +#20802 = CARTESIAN_POINT('',(6.28318530718,20.96992290468)); +#20803 = CARTESIAN_POINT('',(6.568784639324,20.98815419066)); +#20804 = CARTESIAN_POINT('',(6.854383971469,21.041371051011)); +#20805 = CARTESIAN_POINT('',(7.139983303613,21.125262193872)); +#20806 = CARTESIAN_POINT('',(7.425582635758,21.233031178309)); +#20807 = CARTESIAN_POINT('',(7.711181967902,21.355947498293)); +#20808 = CARTESIAN_POINT('',(7.996781300047,21.484052099399)); +#20809 = CARTESIAN_POINT('',(8.282380632191,21.606970833311)); +#20810 = CARTESIAN_POINT('',(8.567979964336,21.714730162034)); +#20811 = CARTESIAN_POINT('',(8.85357929648,21.798657513824)); +#20812 = CARTESIAN_POINT('',(9.139178628625,21.851739194174)); +#20813 = CARTESIAN_POINT('',(9.329578183388,21.864229725544)); +#20814 = CARTESIAN_POINT('',(9.424777960769,21.864000000007)); +#20815 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20816 = PCURVE('',#20817,#20822); +#20817 = PLANE('',#20818); +#20818 = AXIS2_PLACEMENT_3D('',#20819,#20820,#20821); +#20819 = CARTESIAN_POINT('',(-58.,30.300000000024,4.5)); +#20820 = DIRECTION('',(-0.38946828995,-0.921039874882,5.530547345347E-16 + )); +#20821 = DIRECTION('',(0.921039874882,-0.38946828995,2.805518877052E-16) + ); +#20822 = DEFINITIONAL_REPRESENTATION('',(#20823),#20831); +#20823 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20824,#20825,#20826,#20827 + ,#20828,#20829,#20830),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20824 = CARTESIAN_POINT('',(23.940331576676,2.5)); +#20825 = CARTESIAN_POINT('',(23.940331576676,0.681346652053)); +#20826 = CARTESIAN_POINT('',(22.230307892629,1.590673326026)); +#20827 = CARTESIAN_POINT('',(20.520284208583,2.5)); +#20828 = CARTESIAN_POINT('',(22.230307892629,3.409326673974)); +#20829 = CARTESIAN_POINT('',(23.940331576676,4.318653347947)); +#20830 = CARTESIAN_POINT('',(23.940331576676,2.5)); +#20831 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20832 = ADVANCED_FACE('',(#20833),#20847,.F.); +#20833 = FACE_BOUND('',#20834,.F.); +#20834 = EDGE_LOOP('',(#20835,#20865,#20914,#20915)); +#20835 = ORIENTED_EDGE('',*,*,#20836,.T.); +#20836 = EDGE_CURVE('',#20837,#20839,#20841,.T.); +#20837 = VERTEX_POINT('',#20838); +#20838 = CARTESIAN_POINT('',(-38.04999999998,-1.999999999996,7.)); +#20839 = VERTEX_POINT('',#20840); +#20840 = CARTESIAN_POINT('',(-38.04999999998,-9.864000000013,7.)); +#20841 = SEAM_CURVE('',#20842,(#20846,#20858),.PCURVE_S1.); +#20842 = LINE('',#20843,#20844); +#20843 = CARTESIAN_POINT('',(-38.04999999998,3.825592440696E-12,7.)); +#20844 = VECTOR('',#20845,1.); +#20845 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#20846 = PCURVE('',#20847,#20852); +#20847 = CYLINDRICAL_SURFACE('',#20848,1.05); +#20848 = AXIS2_PLACEMENT_3D('',#20849,#20850,#20851); +#20849 = CARTESIAN_POINT('',(-36.99999999998,3.785487712003E-12,7.)); +#20850 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#20851 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#20852 = DEFINITIONAL_REPRESENTATION('',(#20853),#20857); +#20853 = LINE('',#20854,#20855); +#20854 = CARTESIAN_POINT('',(9.424777960769,0.)); +#20855 = VECTOR('',#20856,1.); +#20856 = DIRECTION('',(0.,1.)); +#20857 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20858 = PCURVE('',#20847,#20859); +#20859 = DEFINITIONAL_REPRESENTATION('',(#20860),#20864); +#20860 = LINE('',#20861,#20862); +#20861 = CARTESIAN_POINT('',(3.14159265359,0.)); +#20862 = VECTOR('',#20863,1.); +#20863 = DIRECTION('',(0.,1.)); +#20864 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20865 = ORIENTED_EDGE('',*,*,#20866,.T.); +#20866 = EDGE_CURVE('',#20839,#20839,#20867,.T.); +#20867 = SURFACE_CURVE('',#20868,(#20873,#20902),.PCURVE_S1.); +#20868 = ELLIPSE('',#20869,1.140015789364,1.05); +#20869 = AXIS2_PLACEMENT_3D('',#20870,#20871,#20872); +#20870 = CARTESIAN_POINT('',(-36.99999999998,-9.420000000013,7.)); +#20871 = DIRECTION('',(-0.38946828995,0.921039874882,-1.022559675692E-15 + )); +#20872 = DIRECTION('',(0.921039874882,0.38946828995,-2.358046193053E-32) + ); +#20873 = PCURVE('',#20847,#20874); +#20874 = DEFINITIONAL_REPRESENTATION('',(#20875),#20901); +#20875 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#20876,#20877,#20878,#20879, + #20880,#20881,#20882,#20883,#20884,#20885,#20886,#20887,#20888, + #20889,#20890,#20891,#20892,#20893,#20894,#20895,#20896,#20897, + #20898,#20899,#20900),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(3.14159265359,3.427191985734,3.712791317879 + ,3.998390650023,4.283989982168,4.569589314312,4.855188646457, + 5.140787978601,5.426387310746,5.711986642891,5.997585975035, + 6.28318530718,6.568784639324,6.854383971469,7.139983303613, + 7.425582635758,7.711181967902,7.996781300047,8.282380632191, + 8.567979964336,8.85357929648,9.139178628625,9.424777960769), + .QUASI_UNIFORM_KNOTS.); +#20876 = CARTESIAN_POINT('',(9.424777960769,9.864000000017)); +#20877 = CARTESIAN_POINT('',(9.329578183388,9.864229725555)); +#20878 = CARTESIAN_POINT('',(9.139178628625,9.851739194184)); +#20879 = CARTESIAN_POINT('',(8.85357929648,9.798657513834)); +#20880 = CARTESIAN_POINT('',(8.567979964336,9.714730162044)); +#20881 = CARTESIAN_POINT('',(8.282380632191,9.606970833321)); +#20882 = CARTESIAN_POINT('',(7.996781300047,9.484052099409)); +#20883 = CARTESIAN_POINT('',(7.711181967902,9.355947498303)); +#20884 = CARTESIAN_POINT('',(7.425582635758,9.233031178319)); +#20885 = CARTESIAN_POINT('',(7.139983303613,9.125262193882)); +#20886 = CARTESIAN_POINT('',(6.854383971469,9.041371051021)); +#20887 = CARTESIAN_POINT('',(6.568784639324,8.98815419067)); +#20888 = CARTESIAN_POINT('',(6.28318530718,8.96992290469)); +#20889 = CARTESIAN_POINT('',(5.997585975035,8.98815419067)); +#20890 = CARTESIAN_POINT('',(5.711986642891,9.041371051021)); +#20891 = CARTESIAN_POINT('',(5.426387310746,9.125262193882)); +#20892 = CARTESIAN_POINT('',(5.140787978601,9.233031178319)); +#20893 = CARTESIAN_POINT('',(4.855188646457,9.355947498303)); +#20894 = CARTESIAN_POINT('',(4.569589314312,9.484052099409)); +#20895 = CARTESIAN_POINT('',(4.283989982168,9.606970833321)); +#20896 = CARTESIAN_POINT('',(3.998390650023,9.714730162044)); +#20897 = CARTESIAN_POINT('',(3.712791317879,9.798657513834)); +#20898 = CARTESIAN_POINT('',(3.427191985734,9.851739194184)); +#20899 = CARTESIAN_POINT('',(3.236792430971,9.864229725555)); +#20900 = CARTESIAN_POINT('',(3.14159265359,9.864000000017)); +#20901 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20902 = PCURVE('',#20903,#20908); +#20903 = PLANE('',#20904); +#20904 = AXIS2_PLACEMENT_3D('',#20905,#20906,#20907); +#20905 = CARTESIAN_POINT('',(-22.99999999995,-3.5,4.5)); +#20906 = DIRECTION('',(-0.38946828995,0.921039874882,-1.022559675692E-15 + )); +#20907 = DIRECTION('',(-0.921039874882,-0.38946828995,3.857079200482E-16 + )); +#20908 = DEFINITIONAL_REPRESENTATION('',(#20909),#20913); +#20909 = ELLIPSE('',#20910,1.140015789364,1.05); +#20910 = AXIS2_PLACEMENT_2D('',#20911,#20912); +#20911 = CARTESIAN_POINT('',(15.200210524884,2.5)); +#20912 = DIRECTION('',(-1.,3.857079200482E-16)); +#20913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20914 = ORIENTED_EDGE('',*,*,#20836,.F.); +#20915 = ORIENTED_EDGE('',*,*,#20916,.T.); +#20916 = EDGE_CURVE('',#20837,#20837,#20917,.T.); +#20917 = SURFACE_CURVE('',#20918,(#20923,#20930),.PCURVE_S1.); +#20918 = CIRCLE('',#20919,1.05); +#20919 = AXIS2_PLACEMENT_3D('',#20920,#20921,#20922); +#20920 = CARTESIAN_POINT('',(-36.99999999998,-1.999999999996,7.)); +#20921 = DIRECTION('',(-3.847253546371E-14,-1.,8.553453836232E-16)); +#20922 = DIRECTION('',(1.,-3.847253546371E-14,2.374060347263E-31)); +#20923 = PCURVE('',#20847,#20924); +#20924 = DEFINITIONAL_REPRESENTATION('',(#20925),#20929); +#20925 = LINE('',#20926,#20927); +#20926 = CARTESIAN_POINT('',(0.,2.)); +#20927 = VECTOR('',#20928,1.); +#20928 = DIRECTION('',(1.,0.)); +#20929 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20930 = PCURVE('',#20430,#20931); +#20931 = DEFINITIONAL_REPRESENTATION('',(#20932),#20940); +#20932 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20933,#20934,#20935,#20936 + ,#20937,#20938,#20939),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20933 = CARTESIAN_POINT('',(2.75000000002,12.8)); +#20934 = CARTESIAN_POINT('',(2.75000000002,10.981346652053)); +#20935 = CARTESIAN_POINT('',(1.17500000002,11.890673326026)); +#20936 = CARTESIAN_POINT('',(-0.39999999998,12.8)); +#20937 = CARTESIAN_POINT('',(1.17500000002,13.709326673974)); +#20938 = CARTESIAN_POINT('',(2.75000000002,14.618653347947)); +#20939 = CARTESIAN_POINT('',(2.75000000002,12.8)); +#20940 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20941 = ADVANCED_FACE('',(#20942),#20956,.F.); +#20942 = FACE_BOUND('',#20943,.F.); +#20943 = EDGE_LOOP('',(#20944,#20974,#21005,#21006)); +#20944 = ORIENTED_EDGE('',*,*,#20945,.T.); +#20945 = EDGE_CURVE('',#20946,#20948,#20950,.T.); +#20946 = VERTEX_POINT('',#20947); +#20947 = CARTESIAN_POINT('',(-38.04999999998,-21.86400000001,7.)); +#20948 = VERTEX_POINT('',#20949); +#20949 = CARTESIAN_POINT('',(-38.04999999998,-30.29999999999,7.)); +#20950 = SEAM_CURVE('',#20951,(#20955,#20967),.PCURVE_S1.); +#20951 = LINE('',#20952,#20953); +#20952 = CARTESIAN_POINT('',(-38.04999999998,3.825592440696E-12,7.)); +#20953 = VECTOR('',#20954,1.); +#20954 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#20955 = PCURVE('',#20956,#20961); +#20956 = CYLINDRICAL_SURFACE('',#20957,1.05); +#20957 = AXIS2_PLACEMENT_3D('',#20958,#20959,#20960); +#20958 = CARTESIAN_POINT('',(-36.99999999998,3.785487712003E-12,7.)); +#20959 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#20960 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#20961 = DEFINITIONAL_REPRESENTATION('',(#20962),#20966); +#20962 = LINE('',#20963,#20964); +#20963 = CARTESIAN_POINT('',(9.424777960769,0.)); +#20964 = VECTOR('',#20965,1.); +#20965 = DIRECTION('',(0.,1.)); +#20966 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20967 = PCURVE('',#20956,#20968); +#20968 = DEFINITIONAL_REPRESENTATION('',(#20969),#20973); +#20969 = LINE('',#20970,#20971); +#20970 = CARTESIAN_POINT('',(3.14159265359,0.)); +#20971 = VECTOR('',#20972,1.); +#20972 = DIRECTION('',(0.,1.)); +#20973 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20974 = ORIENTED_EDGE('',*,*,#20975,.T.); +#20975 = EDGE_CURVE('',#20948,#20948,#20976,.T.); +#20976 = SURFACE_CURVE('',#20977,(#20982,#20989),.PCURVE_S1.); +#20977 = CIRCLE('',#20978,1.05); +#20978 = AXIS2_PLACEMENT_3D('',#20979,#20980,#20981); +#20979 = CARTESIAN_POINT('',(-36.99999999998,-30.29999999999,7.)); +#20980 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#20981 = DIRECTION('',(1.,7.556262188718E-13,-6.789912976271E-28)); +#20982 = PCURVE('',#20956,#20983); +#20983 = DEFINITIONAL_REPRESENTATION('',(#20984),#20988); +#20984 = LINE('',#20985,#20986); +#20985 = CARTESIAN_POINT('',(12.566370614359,30.300000000002)); +#20986 = VECTOR('',#20987,1.); +#20987 = DIRECTION('',(-1.,0.)); +#20988 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#20989 = PCURVE('',#20990,#20995); +#20990 = PLANE('',#20991); +#20991 = AXIS2_PLACEMENT_3D('',#20992,#20993,#20994); +#20992 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,19.8)); +#20993 = DIRECTION('',(7.556262188718E-13,-1.,8.553453836232E-16)); +#20994 = DIRECTION('',(-1.,-7.556262188718E-13,6.788313534074E-28)); +#20995 = DEFINITIONAL_REPRESENTATION('',(#20996),#21004); +#20996 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#20997,#20998,#20999,#21000 + ,#21001,#21002,#21003),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#20997 = CARTESIAN_POINT('',(12.950000000002,12.8)); +#20998 = CARTESIAN_POINT('',(12.950000000002,14.618653347947)); +#20999 = CARTESIAN_POINT('',(14.525000000002,13.709326673974)); +#21000 = CARTESIAN_POINT('',(16.100000000002,12.8)); +#21001 = CARTESIAN_POINT('',(14.525000000002,11.890673326026)); +#21002 = CARTESIAN_POINT('',(12.950000000002,10.981346652053)); +#21003 = CARTESIAN_POINT('',(12.950000000002,12.8)); +#21004 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21005 = ORIENTED_EDGE('',*,*,#20945,.F.); +#21006 = ORIENTED_EDGE('',*,*,#21007,.T.); +#21007 = EDGE_CURVE('',#20946,#20946,#21008,.T.); +#21008 = SURFACE_CURVE('',#21009,(#21014,#21043),.PCURVE_S1.); +#21009 = ELLIPSE('',#21010,1.140015789364,1.05); +#21010 = AXIS2_PLACEMENT_3D('',#21011,#21012,#21013); +#21011 = CARTESIAN_POINT('',(-36.99999999998,-21.42000000001,7.)); +#21012 = DIRECTION('',(0.38946828995,-0.921039874882,1.022559675692E-15) + ); +#21013 = DIRECTION('',(0.921039874882,0.38946828995,-2.358046193053E-32) + ); +#21014 = PCURVE('',#20956,#21015); +#21015 = DEFINITIONAL_REPRESENTATION('',(#21016),#21042); +#21016 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#21017,#21018,#21019,#21020, + #21021,#21022,#21023,#21024,#21025,#21026,#21027,#21028,#21029, + #21030,#21031,#21032,#21033,#21034,#21035,#21036,#21037,#21038, + #21039,#21040,#21041),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(3.14159265359,3.427191985734,3.712791317879 + ,3.998390650023,4.283989982168,4.569589314312,4.855188646457, + 5.140787978601,5.426387310746,5.711986642891,5.997585975035, + 6.28318530718,6.568784639324,6.854383971469,7.139983303613, + 7.425582635758,7.711181967902,7.996781300047,8.282380632191, + 8.567979964336,8.85357929648,9.139178628625,9.424777960769), + .QUASI_UNIFORM_KNOTS.); +#21017 = CARTESIAN_POINT('',(3.14159265359,21.864000000015)); +#21018 = CARTESIAN_POINT('',(3.236792430971,21.864229725553)); +#21019 = CARTESIAN_POINT('',(3.427191985734,21.851739194182)); +#21020 = CARTESIAN_POINT('',(3.712791317879,21.798657513832)); +#21021 = CARTESIAN_POINT('',(3.998390650023,21.714730162042)); +#21022 = CARTESIAN_POINT('',(4.283989982168,21.606970833319)); +#21023 = CARTESIAN_POINT('',(4.569589314312,21.484052099407)); +#21024 = CARTESIAN_POINT('',(4.855188646457,21.355947498301)); +#21025 = CARTESIAN_POINT('',(5.140787978601,21.233031178317)); +#21026 = CARTESIAN_POINT('',(5.426387310746,21.12526219388)); +#21027 = CARTESIAN_POINT('',(5.711986642891,21.041371051019)); +#21028 = CARTESIAN_POINT('',(5.997585975035,20.988154190668)); +#21029 = CARTESIAN_POINT('',(6.28318530718,20.969922904688)); +#21030 = CARTESIAN_POINT('',(6.568784639324,20.988154190668)); +#21031 = CARTESIAN_POINT('',(6.854383971469,21.041371051019)); +#21032 = CARTESIAN_POINT('',(7.139983303613,21.12526219388)); +#21033 = CARTESIAN_POINT('',(7.425582635758,21.233031178317)); +#21034 = CARTESIAN_POINT('',(7.711181967902,21.355947498301)); +#21035 = CARTESIAN_POINT('',(7.996781300047,21.484052099407)); +#21036 = CARTESIAN_POINT('',(8.282380632191,21.606970833319)); +#21037 = CARTESIAN_POINT('',(8.567979964336,21.714730162042)); +#21038 = CARTESIAN_POINT('',(8.85357929648,21.798657513832)); +#21039 = CARTESIAN_POINT('',(9.139178628625,21.851739194182)); +#21040 = CARTESIAN_POINT('',(9.329578183388,21.864229725553)); +#21041 = CARTESIAN_POINT('',(9.424777960769,21.864000000015)); +#21042 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21043 = PCURVE('',#21044,#21049); +#21044 = PLANE('',#21045); +#21045 = AXIS2_PLACEMENT_3D('',#21046,#21047,#21048); +#21046 = CARTESIAN_POINT('',(-58.,-30.30000000002,4.5)); +#21047 = DIRECTION('',(0.38946828995,-0.921039874882,1.022559675692E-15) + ); +#21048 = DIRECTION('',(0.921039874882,0.38946828995,-3.857079200482E-16) + ); +#21049 = DEFINITIONAL_REPRESENTATION('',(#21050),#21054); +#21050 = ELLIPSE('',#21051,1.140015789364,1.05); +#21051 = AXIS2_PLACEMENT_2D('',#21052,#21053); +#21052 = CARTESIAN_POINT('',(22.80031578731,2.5)); +#21053 = DIRECTION('',(1.,3.857079200482E-16)); +#21054 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21055 = ADVANCED_FACE('',(#21056),#21070,.F.); +#21056 = FACE_BOUND('',#21057,.F.); +#21057 = EDGE_LOOP('',(#21058,#21088,#21119,#21120)); +#21058 = ORIENTED_EDGE('',*,*,#21059,.T.); +#21059 = EDGE_CURVE('',#21060,#21062,#21064,.T.); +#21060 = VERTEX_POINT('',#21061); +#21061 = CARTESIAN_POINT('',(-73.85,-30.30000000003,7.)); +#21062 = VERTEX_POINT('',#21063); +#21063 = CARTESIAN_POINT('',(-73.85,-20.30000000003,7.)); +#21064 = SEAM_CURVE('',#21065,(#21069,#21081),.PCURVE_S1.); +#21065 = LINE('',#21066,#21067); +#21066 = CARTESIAN_POINT('',(-73.85,-30.30000000003,7.)); +#21067 = VECTOR('',#21068,1.); +#21068 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21069 = PCURVE('',#21070,#21075); +#21070 = CYLINDRICAL_SURFACE('',#21071,1.05); +#21071 = AXIS2_PLACEMENT_3D('',#21072,#21073,#21074); +#21072 = CARTESIAN_POINT('',(-72.8,-30.30000000003,7.)); +#21073 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21074 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#21075 = DEFINITIONAL_REPRESENTATION('',(#21076),#21080); +#21076 = LINE('',#21077,#21078); +#21077 = CARTESIAN_POINT('',(9.424777960769,0.)); +#21078 = VECTOR('',#21079,1.); +#21079 = DIRECTION('',(0.,1.)); +#21080 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21081 = PCURVE('',#21070,#21082); +#21082 = DEFINITIONAL_REPRESENTATION('',(#21083),#21087); +#21083 = LINE('',#21084,#21085); +#21084 = CARTESIAN_POINT('',(3.14159265359,0.)); +#21085 = VECTOR('',#21086,1.); +#21086 = DIRECTION('',(0.,1.)); +#21087 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21088 = ORIENTED_EDGE('',*,*,#21089,.F.); +#21089 = EDGE_CURVE('',#21062,#21062,#21090,.T.); +#21090 = SURFACE_CURVE('',#21091,(#21096,#21103),.PCURVE_S1.); +#21091 = CIRCLE('',#21092,1.05); +#21092 = AXIS2_PLACEMENT_3D('',#21093,#21094,#21095); +#21093 = CARTESIAN_POINT('',(-72.8,-20.30000000003,7.)); +#21094 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#21095 = DIRECTION('',(1.,7.556262188718E-13,-6.789912976271E-28)); +#21096 = PCURVE('',#21070,#21097); +#21097 = DEFINITIONAL_REPRESENTATION('',(#21098),#21102); +#21098 = LINE('',#21099,#21100); +#21099 = CARTESIAN_POINT('',(0.,9.999999999999)); +#21100 = VECTOR('',#21101,1.); +#21101 = DIRECTION('',(1.,0.)); +#21102 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21103 = PCURVE('',#21104,#21109); +#21104 = PLANE('',#21105); +#21105 = AXIS2_PLACEMENT_3D('',#21106,#21107,#21108); +#21106 = CARTESIAN_POINT('',(-72.8,-20.30000000003,21.5)); +#21107 = DIRECTION('',(7.556262188718E-13,-1.,8.553453836232E-16)); +#21108 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21109 = DEFINITIONAL_REPRESENTATION('',(#21110),#21118); +#21110 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21111,#21112,#21113,#21114 + ,#21115,#21116,#21117),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21111 = CARTESIAN_POINT('',(14.5,1.05)); +#21112 = CARTESIAN_POINT('',(16.318653347947,1.05)); +#21113 = CARTESIAN_POINT('',(15.409326673974,-0.525)); +#21114 = CARTESIAN_POINT('',(14.5,-2.1)); +#21115 = CARTESIAN_POINT('',(13.590673326026,-0.525)); +#21116 = CARTESIAN_POINT('',(12.681346652053,1.05)); +#21117 = CARTESIAN_POINT('',(14.5,1.05)); +#21118 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21119 = ORIENTED_EDGE('',*,*,#21059,.F.); +#21120 = ORIENTED_EDGE('',*,*,#21121,.T.); +#21121 = EDGE_CURVE('',#21060,#21060,#21122,.T.); +#21122 = SURFACE_CURVE('',#21123,(#21128,#21135),.PCURVE_S1.); +#21123 = CIRCLE('',#21124,1.05); +#21124 = AXIS2_PLACEMENT_3D('',#21125,#21126,#21127); +#21125 = CARTESIAN_POINT('',(-72.8,-30.30000000004,7.)); +#21126 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#21127 = DIRECTION('',(1.,7.556262188718E-13,-6.789912976271E-28)); +#21128 = PCURVE('',#21070,#21129); +#21129 = DEFINITIONAL_REPRESENTATION('',(#21130),#21134); +#21130 = LINE('',#21131,#21132); +#21131 = CARTESIAN_POINT('',(0.,-6.135536523288E-12)); +#21132 = VECTOR('',#21133,1.); +#21133 = DIRECTION('',(1.,0.)); +#21134 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21135 = PCURVE('',#21136,#21141); +#21136 = PLANE('',#21137); +#21137 = AXIS2_PLACEMENT_3D('',#21138,#21139,#21140); +#21138 = CARTESIAN_POINT('',(-79.46939279485,-30.30000000004, + 43.179056463639)); +#21139 = DIRECTION('',(7.556262188718E-13,-1.,8.553453836232E-16)); +#21140 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21141 = DEFINITIONAL_REPRESENTATION('',(#21142),#21150); +#21142 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21143,#21144,#21145,#21146 + ,#21147,#21148,#21149),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21143 = CARTESIAN_POINT('',(36.179056463639,7.719392794851)); +#21144 = CARTESIAN_POINT('',(37.997709811586,7.719392794851)); +#21145 = CARTESIAN_POINT('',(37.088383137613,6.144392794851)); +#21146 = CARTESIAN_POINT('',(36.179056463639,4.569392794851)); +#21147 = CARTESIAN_POINT('',(35.269729789665,6.144392794851)); +#21148 = CARTESIAN_POINT('',(34.360403115692,7.719392794851)); +#21149 = CARTESIAN_POINT('',(36.179056463639,7.719392794851)); +#21150 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21151 = ADVANCED_FACE('',(#21152),#21104,.T.); +#21152 = FACE_BOUND('',#21153,.T.); +#21153 = EDGE_LOOP('',(#21154)); +#21154 = ORIENTED_EDGE('',*,*,#21089,.F.); +#21155 = ADVANCED_FACE('',(#21156),#21170,.F.); +#21156 = FACE_BOUND('',#21157,.F.); +#21157 = EDGE_LOOP('',(#21158,#21188,#21219,#21220)); +#21158 = ORIENTED_EDGE('',*,*,#21159,.T.); +#21159 = EDGE_CURVE('',#21160,#21162,#21164,.T.); +#21160 = VERTEX_POINT('',#21161); +#21161 = CARTESIAN_POINT('',(-73.85,-30.30000000003,36.)); +#21162 = VERTEX_POINT('',#21163); +#21163 = CARTESIAN_POINT('',(-73.85,-20.30000000003,36.)); +#21164 = SEAM_CURVE('',#21165,(#21169,#21181),.PCURVE_S1.); +#21165 = LINE('',#21166,#21167); +#21166 = CARTESIAN_POINT('',(-73.85,-30.30000000003,36.)); +#21167 = VECTOR('',#21168,1.); +#21168 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21169 = PCURVE('',#21170,#21175); +#21170 = CYLINDRICAL_SURFACE('',#21171,1.05); +#21171 = AXIS2_PLACEMENT_3D('',#21172,#21173,#21174); +#21172 = CARTESIAN_POINT('',(-72.8,-30.30000000003,36.)); +#21173 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21174 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#21175 = DEFINITIONAL_REPRESENTATION('',(#21176),#21180); +#21176 = LINE('',#21177,#21178); +#21177 = CARTESIAN_POINT('',(9.424777960769,0.)); +#21178 = VECTOR('',#21179,1.); +#21179 = DIRECTION('',(0.,1.)); +#21180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21181 = PCURVE('',#21170,#21182); +#21182 = DEFINITIONAL_REPRESENTATION('',(#21183),#21187); +#21183 = LINE('',#21184,#21185); +#21184 = CARTESIAN_POINT('',(3.14159265359,0.)); +#21185 = VECTOR('',#21186,1.); +#21186 = DIRECTION('',(0.,1.)); +#21187 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21188 = ORIENTED_EDGE('',*,*,#21189,.F.); +#21189 = EDGE_CURVE('',#21162,#21162,#21190,.T.); +#21190 = SURFACE_CURVE('',#21191,(#21196,#21203),.PCURVE_S1.); +#21191 = CIRCLE('',#21192,1.05); +#21192 = AXIS2_PLACEMENT_3D('',#21193,#21194,#21195); +#21193 = CARTESIAN_POINT('',(-72.8,-20.30000000003,36.)); +#21194 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#21195 = DIRECTION('',(1.,7.556262188718E-13,-6.789912976271E-28)); +#21196 = PCURVE('',#21170,#21197); +#21197 = DEFINITIONAL_REPRESENTATION('',(#21198),#21202); +#21198 = LINE('',#21199,#21200); +#21199 = CARTESIAN_POINT('',(0.,9.999999999999)); +#21200 = VECTOR('',#21201,1.); +#21201 = DIRECTION('',(1.,0.)); +#21202 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21203 = PCURVE('',#21204,#21209); +#21204 = PLANE('',#21205); +#21205 = AXIS2_PLACEMENT_3D('',#21206,#21207,#21208); +#21206 = CARTESIAN_POINT('',(-72.8,-20.30000000003,21.5)); +#21207 = DIRECTION('',(7.556262188718E-13,-1.,8.553453836232E-16)); +#21208 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21209 = DEFINITIONAL_REPRESENTATION('',(#21210),#21218); +#21210 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21211,#21212,#21213,#21214 + ,#21215,#21216,#21217),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21211 = CARTESIAN_POINT('',(-14.5,1.05)); +#21212 = CARTESIAN_POINT('',(-12.68134665205,1.05)); +#21213 = CARTESIAN_POINT('',(-13.59067332602,-0.525)); +#21214 = CARTESIAN_POINT('',(-14.5,-2.1)); +#21215 = CARTESIAN_POINT('',(-15.40932667397,-0.525)); +#21216 = CARTESIAN_POINT('',(-16.31865334794,1.05)); +#21217 = CARTESIAN_POINT('',(-14.5,1.05)); +#21218 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21219 = ORIENTED_EDGE('',*,*,#21159,.F.); +#21220 = ORIENTED_EDGE('',*,*,#21221,.T.); +#21221 = EDGE_CURVE('',#21160,#21160,#21222,.T.); +#21222 = SURFACE_CURVE('',#21223,(#21228,#21235),.PCURVE_S1.); +#21223 = CIRCLE('',#21224,1.05); +#21224 = AXIS2_PLACEMENT_3D('',#21225,#21226,#21227); +#21225 = CARTESIAN_POINT('',(-72.8,-30.30000000004,36.)); +#21226 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#21227 = DIRECTION('',(1.,7.556262188718E-13,-6.789912976271E-28)); +#21228 = PCURVE('',#21170,#21229); +#21229 = DEFINITIONAL_REPRESENTATION('',(#21230),#21234); +#21230 = LINE('',#21231,#21232); +#21231 = CARTESIAN_POINT('',(0.,-6.135536523288E-12)); +#21232 = VECTOR('',#21233,1.); +#21233 = DIRECTION('',(1.,0.)); +#21234 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21235 = PCURVE('',#21136,#21236); +#21236 = DEFINITIONAL_REPRESENTATION('',(#21237),#21245); +#21237 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21238,#21239,#21240,#21241 + ,#21242,#21243,#21244),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21238 = CARTESIAN_POINT('',(7.179056463639,7.719392794851)); +#21239 = CARTESIAN_POINT('',(8.997709811586,7.719392794851)); +#21240 = CARTESIAN_POINT('',(8.088383137613,6.144392794851)); +#21241 = CARTESIAN_POINT('',(7.179056463639,4.569392794851)); +#21242 = CARTESIAN_POINT('',(6.269729789665,6.144392794851)); +#21243 = CARTESIAN_POINT('',(5.360403115692,7.719392794851)); +#21244 = CARTESIAN_POINT('',(7.179056463639,7.719392794851)); +#21245 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21246 = ADVANCED_FACE('',(#21247),#21204,.T.); +#21247 = FACE_BOUND('',#21248,.T.); +#21248 = EDGE_LOOP('',(#21249)); +#21249 = ORIENTED_EDGE('',*,*,#21189,.F.); +#21250 = ADVANCED_FACE('',(#21251),#21265,.F.); +#21251 = FACE_BOUND('',#21252,.F.); +#21252 = EDGE_LOOP('',(#21253,#21283,#21314,#21315)); +#21253 = ORIENTED_EDGE('',*,*,#21254,.T.); +#21254 = EDGE_CURVE('',#21255,#21257,#21259,.T.); +#21255 = VERTEX_POINT('',#21256); +#21256 = CARTESIAN_POINT('',(-73.85,30.300000000035,7.)); +#21257 = VERTEX_POINT('',#21258); +#21258 = CARTESIAN_POINT('',(-73.85,20.300000000035,7.)); +#21259 = SEAM_CURVE('',#21260,(#21264,#21276),.PCURVE_S1.); +#21260 = LINE('',#21261,#21262); +#21261 = CARTESIAN_POINT('',(-73.85,30.300000000035,7.)); +#21262 = VECTOR('',#21263,1.); +#21263 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21264 = PCURVE('',#21265,#21270); +#21265 = CYLINDRICAL_SURFACE('',#21266,1.05); +#21266 = AXIS2_PLACEMENT_3D('',#21267,#21268,#21269); +#21267 = CARTESIAN_POINT('',(-72.8,30.300000000035,7.)); +#21268 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21269 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#21270 = DEFINITIONAL_REPRESENTATION('',(#21271),#21275); +#21271 = LINE('',#21272,#21273); +#21272 = CARTESIAN_POINT('',(9.424777960769,0.)); +#21273 = VECTOR('',#21274,1.); +#21274 = DIRECTION('',(0.,1.)); +#21275 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21276 = PCURVE('',#21265,#21277); +#21277 = DEFINITIONAL_REPRESENTATION('',(#21278),#21282); +#21278 = LINE('',#21279,#21280); +#21279 = CARTESIAN_POINT('',(3.14159265359,0.)); +#21280 = VECTOR('',#21281,1.); +#21281 = DIRECTION('',(0.,1.)); +#21282 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21283 = ORIENTED_EDGE('',*,*,#21284,.F.); +#21284 = EDGE_CURVE('',#21257,#21257,#21285,.T.); +#21285 = SURFACE_CURVE('',#21286,(#21291,#21298),.PCURVE_S1.); +#21286 = CIRCLE('',#21287,1.05); +#21287 = AXIS2_PLACEMENT_3D('',#21288,#21289,#21290); +#21288 = CARTESIAN_POINT('',(-72.8,20.300000000035,7.)); +#21289 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#21290 = DIRECTION('',(1.,-7.556212847502E-13,6.136472781081E-28)); +#21291 = PCURVE('',#21265,#21292); +#21292 = DEFINITIONAL_REPRESENTATION('',(#21293),#21297); +#21293 = LINE('',#21294,#21295); +#21294 = CARTESIAN_POINT('',(0.,9.999999999999)); +#21295 = VECTOR('',#21296,1.); +#21296 = DIRECTION('',(1.,0.)); +#21297 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21298 = PCURVE('',#21299,#21304); +#21299 = PLANE('',#21300); +#21300 = AXIS2_PLACEMENT_3D('',#21301,#21302,#21303); +#21301 = CARTESIAN_POINT('',(-72.8,20.300000000035,21.5)); +#21302 = DIRECTION('',(7.556212847502E-13,1.,-8.553453836232E-16)); +#21303 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#21304 = DEFINITIONAL_REPRESENTATION('',(#21305),#21313); +#21305 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21306,#21307,#21308,#21309 + ,#21310,#21311,#21312),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21306 = CARTESIAN_POINT('',(-14.5,1.05)); +#21307 = CARTESIAN_POINT('',(-12.68134665205,1.05)); +#21308 = CARTESIAN_POINT('',(-13.59067332602,-0.525)); +#21309 = CARTESIAN_POINT('',(-14.5,-2.1)); +#21310 = CARTESIAN_POINT('',(-15.40932667397,-0.525)); +#21311 = CARTESIAN_POINT('',(-16.31865334794,1.05)); +#21312 = CARTESIAN_POINT('',(-14.5,1.05)); +#21313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21314 = ORIENTED_EDGE('',*,*,#21254,.F.); +#21315 = ORIENTED_EDGE('',*,*,#21316,.T.); +#21316 = EDGE_CURVE('',#21255,#21255,#21317,.T.); +#21317 = SURFACE_CURVE('',#21318,(#21323,#21330),.PCURVE_S1.); +#21318 = CIRCLE('',#21319,1.05); +#21319 = AXIS2_PLACEMENT_3D('',#21320,#21321,#21322); +#21320 = CARTESIAN_POINT('',(-72.8,30.30000000004,7.)); +#21321 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#21322 = DIRECTION('',(1.,-7.556212847502E-13,6.136472781081E-28)); +#21323 = PCURVE('',#21265,#21324); +#21324 = DEFINITIONAL_REPRESENTATION('',(#21325),#21329); +#21325 = LINE('',#21326,#21327); +#21326 = CARTESIAN_POINT('',(0.,-5.552891479965E-12)); +#21327 = VECTOR('',#21328,1.); +#21328 = DIRECTION('',(1.,0.)); +#21329 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21330 = PCURVE('',#21331,#21336); +#21331 = PLANE('',#21332); +#21332 = AXIS2_PLACEMENT_3D('',#21333,#21334,#21335); +#21333 = CARTESIAN_POINT('',(-79.46939279485,30.30000000004, + 43.179056463639)); +#21334 = DIRECTION('',(7.556212847502E-13,1.,-8.553453836232E-16)); +#21335 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#21336 = DEFINITIONAL_REPRESENTATION('',(#21337),#21345); +#21337 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21338,#21339,#21340,#21341 + ,#21342,#21343,#21344),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21338 = CARTESIAN_POINT('',(-36.17905646363,7.719392794851)); +#21339 = CARTESIAN_POINT('',(-34.36040311569,7.719392794851)); +#21340 = CARTESIAN_POINT('',(-35.26972978966,6.144392794851)); +#21341 = CARTESIAN_POINT('',(-36.17905646363,4.569392794851)); +#21342 = CARTESIAN_POINT('',(-37.08838313761,6.144392794851)); +#21343 = CARTESIAN_POINT('',(-37.99770981158,7.719392794851)); +#21344 = CARTESIAN_POINT('',(-36.17905646363,7.719392794851)); +#21345 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21346 = ADVANCED_FACE('',(#21347),#21299,.T.); +#21347 = FACE_BOUND('',#21348,.T.); +#21348 = EDGE_LOOP('',(#21349)); +#21349 = ORIENTED_EDGE('',*,*,#21284,.F.); +#21350 = ADVANCED_FACE('',(#21351),#21365,.F.); +#21351 = FACE_BOUND('',#21352,.F.); +#21352 = EDGE_LOOP('',(#21353,#21383,#21414,#21415)); +#21353 = ORIENTED_EDGE('',*,*,#21354,.T.); +#21354 = EDGE_CURVE('',#21355,#21357,#21359,.T.); +#21355 = VERTEX_POINT('',#21356); +#21356 = CARTESIAN_POINT('',(-73.85,30.300000000035,36.)); +#21357 = VERTEX_POINT('',#21358); +#21358 = CARTESIAN_POINT('',(-73.85,20.300000000035,36.)); +#21359 = SEAM_CURVE('',#21360,(#21364,#21376),.PCURVE_S1.); +#21360 = LINE('',#21361,#21362); +#21361 = CARTESIAN_POINT('',(-73.85,30.300000000035,36.)); +#21362 = VECTOR('',#21363,1.); +#21363 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21364 = PCURVE('',#21365,#21370); +#21365 = CYLINDRICAL_SURFACE('',#21366,1.05); +#21366 = AXIS2_PLACEMENT_3D('',#21367,#21368,#21369); +#21367 = CARTESIAN_POINT('',(-72.8,30.300000000035,36.)); +#21368 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21369 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#21370 = DEFINITIONAL_REPRESENTATION('',(#21371),#21375); +#21371 = LINE('',#21372,#21373); +#21372 = CARTESIAN_POINT('',(9.424777960769,0.)); +#21373 = VECTOR('',#21374,1.); +#21374 = DIRECTION('',(0.,1.)); +#21375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21376 = PCURVE('',#21365,#21377); +#21377 = DEFINITIONAL_REPRESENTATION('',(#21378),#21382); +#21378 = LINE('',#21379,#21380); +#21379 = CARTESIAN_POINT('',(3.14159265359,0.)); +#21380 = VECTOR('',#21381,1.); +#21381 = DIRECTION('',(0.,1.)); +#21382 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21383 = ORIENTED_EDGE('',*,*,#21384,.F.); +#21384 = EDGE_CURVE('',#21357,#21357,#21385,.T.); +#21385 = SURFACE_CURVE('',#21386,(#21391,#21398),.PCURVE_S1.); +#21386 = CIRCLE('',#21387,1.05); +#21387 = AXIS2_PLACEMENT_3D('',#21388,#21389,#21390); +#21388 = CARTESIAN_POINT('',(-72.8,20.300000000035,36.)); +#21389 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#21390 = DIRECTION('',(1.,-7.556212847502E-13,6.136472781081E-28)); +#21391 = PCURVE('',#21365,#21392); +#21392 = DEFINITIONAL_REPRESENTATION('',(#21393),#21397); +#21393 = LINE('',#21394,#21395); +#21394 = CARTESIAN_POINT('',(0.,9.999999999999)); +#21395 = VECTOR('',#21396,1.); +#21396 = DIRECTION('',(1.,0.)); +#21397 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21398 = PCURVE('',#21399,#21404); +#21399 = PLANE('',#21400); +#21400 = AXIS2_PLACEMENT_3D('',#21401,#21402,#21403); +#21401 = CARTESIAN_POINT('',(-72.8,20.300000000035,21.5)); +#21402 = DIRECTION('',(7.556212847502E-13,1.,-8.553453836232E-16)); +#21403 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#21404 = DEFINITIONAL_REPRESENTATION('',(#21405),#21413); +#21405 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21406,#21407,#21408,#21409 + ,#21410,#21411,#21412),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21406 = CARTESIAN_POINT('',(14.5,1.05)); +#21407 = CARTESIAN_POINT('',(16.318653347947,1.05)); +#21408 = CARTESIAN_POINT('',(15.409326673974,-0.525)); +#21409 = CARTESIAN_POINT('',(14.5,-2.1)); +#21410 = CARTESIAN_POINT('',(13.590673326026,-0.525)); +#21411 = CARTESIAN_POINT('',(12.681346652053,1.05)); +#21412 = CARTESIAN_POINT('',(14.5,1.05)); +#21413 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21414 = ORIENTED_EDGE('',*,*,#21354,.F.); +#21415 = ORIENTED_EDGE('',*,*,#21416,.T.); +#21416 = EDGE_CURVE('',#21355,#21355,#21417,.T.); +#21417 = SURFACE_CURVE('',#21418,(#21423,#21430),.PCURVE_S1.); +#21418 = CIRCLE('',#21419,1.05); +#21419 = AXIS2_PLACEMENT_3D('',#21420,#21421,#21422); +#21420 = CARTESIAN_POINT('',(-72.8,30.30000000004,36.)); +#21421 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#21422 = DIRECTION('',(1.,-7.556212847502E-13,6.136472781081E-28)); +#21423 = PCURVE('',#21365,#21424); +#21424 = DEFINITIONAL_REPRESENTATION('',(#21425),#21429); +#21425 = LINE('',#21426,#21427); +#21426 = CARTESIAN_POINT('',(0.,-5.552891479965E-12)); +#21427 = VECTOR('',#21428,1.); +#21428 = DIRECTION('',(1.,0.)); +#21429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21430 = PCURVE('',#21331,#21431); +#21431 = DEFINITIONAL_REPRESENTATION('',(#21432),#21440); +#21432 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21433,#21434,#21435,#21436 + ,#21437,#21438,#21439),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21433 = CARTESIAN_POINT('',(-7.179056463639,7.719392794851)); +#21434 = CARTESIAN_POINT('',(-5.360403115692,7.719392794851)); +#21435 = CARTESIAN_POINT('',(-6.269729789665,6.144392794851)); +#21436 = CARTESIAN_POINT('',(-7.179056463639,4.569392794851)); +#21437 = CARTESIAN_POINT('',(-8.088383137613,6.144392794851)); +#21438 = CARTESIAN_POINT('',(-8.997709811586,7.719392794851)); +#21439 = CARTESIAN_POINT('',(-7.179056463639,7.719392794851)); +#21440 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21441 = ADVANCED_FACE('',(#21442),#21399,.T.); +#21442 = FACE_BOUND('',#21443,.T.); +#21443 = EDGE_LOOP('',(#21444)); +#21444 = ORIENTED_EDGE('',*,*,#21384,.F.); +#21445 = ADVANCED_FACE('',(#21446),#21461,.T.); +#21446 = FACE_BOUND('',#21447,.T.); +#21447 = EDGE_LOOP('',(#21448,#21483,#21511,#21539)); +#21448 = ORIENTED_EDGE('',*,*,#21449,.T.); +#21449 = EDGE_CURVE('',#21450,#21452,#21454,.T.); +#21450 = VERTEX_POINT('',#21451); +#21451 = CARTESIAN_POINT('',(-73.3153689607,-30.30000000003, + 52.666293034401)); +#21452 = VERTEX_POINT('',#21453); +#21453 = CARTESIAN_POINT('',(-70.3,-30.30000000003,35.565285868117)); +#21454 = SURFACE_CURVE('',#21455,(#21460,#21472),.PCURVE_S1.); +#21455 = CIRCLE('',#21456,50.); +#21456 = AXIS2_PLACEMENT_3D('',#21457,#21458,#21459); +#21457 = CARTESIAN_POINT('',(-120.3,-30.30000000003,35.565285868117)); +#21458 = DIRECTION('',(-7.556262188718E-13,1.,-8.553453836232E-16)); +#21459 = DIRECTION('',(0.939692620786,7.103489272969E-13,0.342020143326) + ); +#21460 = PCURVE('',#21461,#21466); +#21461 = CYLINDRICAL_SURFACE('',#21462,50.); +#21462 = AXIS2_PLACEMENT_3D('',#21463,#21464,#21465); +#21463 = CARTESIAN_POINT('',(-120.3,6.967129521643E-12,35.565285868117) + ); +#21464 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21465 = DIRECTION('',(0.939692620786,-3.589154058225E-14,0.342020143326 + )); +#21466 = DEFINITIONAL_REPRESENTATION('',(#21467),#21471); +#21467 = LINE('',#21468,#21469); +#21468 = CARTESIAN_POINT('',(0.,-30.3)); +#21469 = VECTOR('',#21470,1.); +#21470 = DIRECTION('',(1.,6.819109237058E-12)); +#21471 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21472 = PCURVE('',#21136,#21473); +#21473 = DEFINITIONAL_REPRESENTATION('',(#21474),#21482); +#21474 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21475,#21476,#21477,#21478 + ,#21479,#21480,#21481),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21475 = CARTESIAN_POINT('',(-9.487236570762,6.154023834146)); +#21476 = CARTESIAN_POINT('',(71.892531564175,35.773837106749)); +#21477 = CARTESIAN_POINT('',(56.854158246133,-49.51301608849)); +#21478 = CARTESIAN_POINT('',(41.81578492809,-134.7998692837)); +#21479 = CARTESIAN_POINT('',(-24.5256098888,-79.13282936109)); +#21480 = CARTESIAN_POINT('',(-90.86700470569,-23.46578943845)); +#21481 = CARTESIAN_POINT('',(-9.487236570762,6.154023834146)); +#21482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21483 = ORIENTED_EDGE('',*,*,#21484,.T.); +#21484 = EDGE_CURVE('',#21452,#21485,#21487,.T.); +#21485 = VERTEX_POINT('',#21486); +#21486 = CARTESIAN_POINT('',(-70.3,30.300000000033,35.565285868117)); +#21487 = SURFACE_CURVE('',#21488,(#21492,#21499),.PCURVE_S1.); +#21488 = LINE('',#21489,#21490); +#21489 = CARTESIAN_POINT('',(-70.3,5.057380536265E-12,35.565285868117)); +#21490 = VECTOR('',#21491,1.); +#21491 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21492 = PCURVE('',#21461,#21493); +#21493 = DEFINITIONAL_REPRESENTATION('',(#21494),#21498); +#21494 = LINE('',#21495,#21496); +#21495 = CARTESIAN_POINT('',(0.349065850399,0.)); +#21496 = VECTOR('',#21497,1.); +#21497 = DIRECTION('',(0.,1.)); +#21498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21499 = PCURVE('',#21500,#21505); +#21500 = PLANE('',#21501); +#21501 = AXIS2_PLACEMENT_3D('',#21502,#21503,#21504); +#21502 = CARTESIAN_POINT('',(-70.3,5.057380536265E-12,43.5)); +#21503 = DIRECTION('',(1.,-3.819497970755E-14,-2.277380563334E-16)); +#21504 = DIRECTION('',(-2.277380563334E-16,8.69845044029E-30,-1.)); +#21505 = DEFINITIONAL_REPRESENTATION('',(#21506),#21510); +#21506 = LINE('',#21507,#21508); +#21507 = CARTESIAN_POINT('',(7.934714131883,0.)); +#21508 = VECTOR('',#21509,1.); +#21509 = DIRECTION('',(-1.771134042476E-116,1.)); +#21510 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21511 = ORIENTED_EDGE('',*,*,#21512,.T.); +#21512 = EDGE_CURVE('',#21485,#21513,#21515,.T.); +#21513 = VERTEX_POINT('',#21514); +#21514 = CARTESIAN_POINT('',(-73.3153689607,30.300000000035, + 52.666293034401)); +#21515 = SURFACE_CURVE('',#21516,(#21521,#21528),.PCURVE_S1.); +#21516 = CIRCLE('',#21517,50.); +#21517 = AXIS2_PLACEMENT_3D('',#21518,#21519,#21520); +#21518 = CARTESIAN_POINT('',(-120.3,30.300000000042,35.565285868117)); +#21519 = DIRECTION('',(-7.556212847502E-13,-1.,8.553453836232E-16)); +#21520 = DIRECTION('',(0.939692620786,-7.097592000378E-13,0.342020143326 + )); +#21521 = PCURVE('',#21461,#21522); +#21522 = DEFINITIONAL_REPRESENTATION('',(#21523),#21527); +#21523 = LINE('',#21524,#21525); +#21524 = CARTESIAN_POINT('',(6.28318530718,30.299999999962)); +#21525 = VECTOR('',#21526,1.); +#21526 = DIRECTION('',(-1.,6.238976063159E-12)); +#21527 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21528 = PCURVE('',#21331,#21529); +#21529 = DEFINITIONAL_REPRESENTATION('',(#21530),#21538); +#21530 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#21531,#21532,#21533,#21534 + ,#21535,#21536,#21537),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#21531 = CARTESIAN_POINT('',(9.487236570762,6.154023834146)); +#21532 = CARTESIAN_POINT('',(90.867004705699,-23.46578943845)); +#21533 = CARTESIAN_POINT('',(24.525609888804,-79.13282936109)); +#21534 = CARTESIAN_POINT('',(-41.81578492809,-134.7998692837)); +#21535 = CARTESIAN_POINT('',(-56.85415824613,-49.51301608849)); +#21536 = CARTESIAN_POINT('',(-71.89253156417,35.773837106749)); +#21537 = CARTESIAN_POINT('',(9.487236570762,6.154023834146)); +#21538 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21539 = ORIENTED_EDGE('',*,*,#21540,.T.); +#21540 = EDGE_CURVE('',#21513,#21450,#21541,.T.); +#21541 = SURFACE_CURVE('',#21542,(#21546,#21553),.PCURVE_S1.); +#21542 = LINE('',#21543,#21544); +#21543 = CARTESIAN_POINT('',(-73.3153689607,5.17255249253E-12, + 52.666293034401)); +#21544 = VECTOR('',#21545,1.); +#21545 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21546 = PCURVE('',#21461,#21547); +#21547 = DEFINITIONAL_REPRESENTATION('',(#21548),#21552); +#21548 = LINE('',#21549,#21550); +#21549 = CARTESIAN_POINT('',(0.,0.)); +#21550 = VECTOR('',#21551,1.); +#21551 = DIRECTION('',(0.,-1.)); +#21552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21553 = PCURVE('',#21554,#21559); +#21554 = PLANE('',#21555); +#21555 = AXIS2_PLACEMENT_3D('',#21556,#21557,#21558); +#21556 = CARTESIAN_POINT('',(-83.94032248577,5.578372376814E-12, + 81.858112927278)); +#21557 = DIRECTION('',(0.939692620786,-3.589154058225E-14,0.342020143326 + )); +#21558 = DIRECTION('',(0.342020143326,-1.30634524339E-14,-0.939692620786 + )); +#21559 = DEFINITIONAL_REPRESENTATION('',(#21560),#21564); +#21560 = LINE('',#21561,#21562); +#21561 = CARTESIAN_POINT('',(31.065285868121,4.131548585016E-100)); +#21562 = VECTOR('',#21563,1.); +#21563 = DIRECTION('',(-2.65991344973E-101,-1.)); +#21564 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21565 = ADVANCED_FACE('',(#21566,#21754,#21757),#21331,.T.); +#21566 = FACE_BOUND('',#21567,.T.); +#21567 = EDGE_LOOP('',(#21568,#21569,#21592,#21620,#21648,#21677,#21705, + #21733)); +#21568 = ORIENTED_EDGE('',*,*,#21512,.F.); +#21569 = ORIENTED_EDGE('',*,*,#21570,.F.); +#21570 = EDGE_CURVE('',#21571,#21485,#21573,.T.); +#21571 = VERTEX_POINT('',#21572); +#21572 = CARTESIAN_POINT('',(-70.3,30.300000000033,4.5)); +#21573 = SURFACE_CURVE('',#21574,(#21578,#21585),.PCURVE_S1.); +#21574 = LINE('',#21575,#21576); +#21575 = CARTESIAN_POINT('',(-70.3,30.300000000033,43.33952823182)); +#21576 = VECTOR('',#21577,1.); +#21577 = DIRECTION('',(2.277380563334E-16,8.55345383623E-16,1.)); +#21578 = PCURVE('',#21331,#21579); +#21579 = DEFINITIONAL_REPRESENTATION('',(#21580),#21584); +#21580 = LINE('',#21581,#21582); +#21581 = CARTESIAN_POINT('',(0.16047176818,9.169392794851)); +#21582 = VECTOR('',#21583,1.); +#21583 = DIRECTION('',(1.,2.277380563334E-16)); +#21584 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21585 = PCURVE('',#21500,#21586); +#21586 = DEFINITIONAL_REPRESENTATION('',(#21587),#21591); +#21587 = LINE('',#21588,#21589); +#21588 = CARTESIAN_POINT('',(0.16047176818,30.300000000028)); +#21589 = VECTOR('',#21590,1.); +#21590 = DIRECTION('',(-1.,8.55345383623E-16)); +#21591 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21592 = ORIENTED_EDGE('',*,*,#21593,.F.); +#21593 = EDGE_CURVE('',#21594,#21571,#21596,.T.); +#21594 = VERTEX_POINT('',#21595); +#21595 = CARTESIAN_POINT('',(-75.3,30.300000000037,4.5)); +#21596 = SURFACE_CURVE('',#21597,(#21601,#21608),.PCURVE_S1.); +#21597 = LINE('',#21598,#21599); +#21598 = CARTESIAN_POINT('',(-74.88469639741,30.300000000037,4.5)); +#21599 = VECTOR('',#21600,1.); +#21600 = DIRECTION('',(1.,-7.556212847502E-13,-2.24207754292E-44)); +#21601 = PCURVE('',#21331,#21602); +#21602 = DEFINITIONAL_REPRESENTATION('',(#21603),#21607); +#21603 = LINE('',#21604,#21605); +#21604 = CARTESIAN_POINT('',(-38.67905646363,4.584696397436)); +#21605 = VECTOR('',#21606,1.); +#21606 = DIRECTION('',(-6.136472781081E-28,1.)); +#21607 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21608 = PCURVE('',#21609,#21614); +#21609 = PLANE('',#21610); +#21610 = AXIS2_PLACEMENT_3D('',#21611,#21612,#21613); +#21611 = CARTESIAN_POINT('',(-46.64999999997,-15.15000000001,4.5)); +#21612 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21613 = DIRECTION('',(-1.,3.819497970755E-14,2.24207754292E-44)); +#21614 = DEFINITIONAL_REPRESENTATION('',(#21615),#21619); +#21615 = LINE('',#21616,#21617); +#21616 = CARTESIAN_POINT('',(28.234696397437,45.450000000046)); +#21617 = VECTOR('',#21618,1.); +#21618 = DIRECTION('',(-1.,-7.174263050427E-13)); +#21619 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21620 = ORIENTED_EDGE('',*,*,#21621,.F.); +#21621 = EDGE_CURVE('',#21622,#21594,#21624,.T.); +#21622 = VERTEX_POINT('',#21623); +#21623 = CARTESIAN_POINT('',(-75.3,30.300000000037,36.446920771661)); +#21624 = SURFACE_CURVE('',#21625,(#21629,#21636),.PCURVE_S1.); +#21625 = LINE('',#21626,#21627); +#21626 = CARTESIAN_POINT('',(-75.3,30.300000000037,23.83952823182)); +#21627 = VECTOR('',#21628,1.); +#21628 = DIRECTION('',(-7.970831971668E-16,-8.553453836226E-16,-1.)); +#21629 = PCURVE('',#21331,#21630); +#21630 = DEFINITIONAL_REPRESENTATION('',(#21631),#21635); +#21631 = LINE('',#21632,#21633); +#21632 = CARTESIAN_POINT('',(-19.33952823182,4.169392794851)); +#21633 = VECTOR('',#21634,1.); +#21634 = DIRECTION('',(-1.,-7.970831971668E-16)); +#21635 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21636 = PCURVE('',#21637,#21642); +#21637 = PLANE('',#21638); +#21638 = AXIS2_PLACEMENT_3D('',#21639,#21640,#21641); +#21639 = CARTESIAN_POINT('',(-75.3,5.248355434803E-12,4.5)); +#21640 = DIRECTION('',(-1.,3.819497970755E-14,7.970831971668E-16)); +#21641 = DIRECTION('',(7.970831971668E-16,-3.044457654101E-29,1.)); +#21642 = DEFINITIONAL_REPRESENTATION('',(#21643),#21647); +#21643 = LINE('',#21644,#21645); +#21644 = CARTESIAN_POINT('',(19.33952823182,30.300000000032)); +#21645 = VECTOR('',#21646,1.); +#21646 = DIRECTION('',(-1.,-8.553453836226E-16)); +#21647 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21648 = ORIENTED_EDGE('',*,*,#21649,.F.); +#21649 = EDGE_CURVE('',#21650,#21622,#21652,.T.); +#21650 = VERTEX_POINT('',#21651); +#21651 = CARTESIAN_POINT('',(-77.71229516856,30.300000000039, + 50.127726504689)); +#21652 = SURFACE_CURVE('',#21653,(#21658,#21665),.PCURVE_S1.); +#21653 = CIRCLE('',#21654,40.); +#21654 = AXIS2_PLACEMENT_3D('',#21655,#21656,#21657); +#21655 = CARTESIAN_POINT('',(-115.3,30.300000000041,36.446920771661)); +#21656 = DIRECTION('',(7.556212847502E-13,1.,-8.553453836232E-16)); +#21657 = DIRECTION('',(0.984807753012,-7.439931703959E-13,0.173648177667 + )); +#21658 = PCURVE('',#21331,#21659); +#21659 = DEFINITIONAL_REPRESENTATION('',(#21660),#21664); +#21660 = CIRCLE('',#21661,40.); +#21661 = AXIS2_PLACEMENT_2D('',#21662,#21663); +#21662 = CARTESIAN_POINT('',(-6.732135691978,-35.83060720514)); +#21663 = DIRECTION('',(0.173648177667,0.984807753012)); +#21664 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21665 = PCURVE('',#21666,#21671); +#21666 = CYLINDRICAL_SURFACE('',#21667,40.); +#21667 = AXIS2_PLACEMENT_3D('',#21668,#21669,#21670); +#21668 = CARTESIAN_POINT('',(-115.3,6.776154623105E-12,36.446920771661) + ); +#21669 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#21670 = DIRECTION('',(0.984807753012,-3.761471214214E-14,0.173648177667 + )); +#21671 = DEFINITIONAL_REPRESENTATION('',(#21672),#21676); +#21672 = LINE('',#21673,#21674); +#21673 = CARTESIAN_POINT('',(6.28318530718,-30.30000000003)); +#21674 = VECTOR('',#21675,1.); +#21675 = DIRECTION('',(-1.,4.997287515515E-12)); +#21676 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21677 = ORIENTED_EDGE('',*,*,#21678,.F.); +#21678 = EDGE_CURVE('',#21679,#21650,#21681,.T.); +#21679 = VERTEX_POINT('',#21680); +#21680 = CARTESIAN_POINT('',(-85.21858415644,30.300000000044, + 70.751086002789)); +#21681 = SURFACE_CURVE('',#21682,(#21686,#21693),.PCURVE_S1.); +#21682 = LINE('',#21683,#21684); +#21683 = CARTESIAN_POINT('',(-75.49228852114,30.300000000037, + 44.028308369872)); +#21684 = VECTOR('',#21685,1.); +#21685 = DIRECTION('',(0.342020143326,-2.592414618554E-13, + -0.939692620786)); +#21686 = PCURVE('',#21331,#21687); +#21687 = DEFINITIONAL_REPRESENTATION('',(#21688),#21692); +#21688 = LINE('',#21689,#21690); +#21689 = CARTESIAN_POINT('',(0.849251906233,3.977104273704)); +#21690 = VECTOR('',#21691,1.); +#21691 = DIRECTION('',(-0.939692620786,0.342020143326)); +#21692 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21693 = PCURVE('',#21694,#21699); +#21694 = PLANE('',#21695); +#21695 = AXIS2_PLACEMENT_3D('',#21696,#21697,#21698); +#21696 = CARTESIAN_POINT('',(-75.3,5.248355434803E-12,43.5)); +#21697 = DIRECTION('',(-0.939692620786,3.589154058225E-14, + -0.342020143326)); +#21698 = DIRECTION('',(-0.342020143326,1.30634524339E-14,0.939692620786) + ); +#21699 = DEFINITIONAL_REPRESENTATION('',(#21700),#21704); +#21700 = LINE('',#21701,#21702); +#21701 = CARTESIAN_POINT('',(0.562214024231,30.300000000032)); +#21702 = VECTOR('',#21703,1.); +#21703 = DIRECTION('',(-1.,-2.461780094215E-13)); +#21704 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21705 = ORIENTED_EDGE('',*,*,#21706,.F.); +#21706 = EDGE_CURVE('',#21707,#21679,#21709,.T.); +#21707 = VERTEX_POINT('',#21708); +#21708 = CARTESIAN_POINT('',(-80.52012105251,30.300000000041, + 72.461186719417)); +#21709 = SURFACE_CURVE('',#21710,(#21714,#21721),.PCURVE_S1.); +#21710 = LINE('',#21711,#21712); +#21711 = CARTESIAN_POINT('',(-87.11099203271,30.300000000046, + 70.062305864737)); +#21712 = VECTOR('',#21713,1.); +#21713 = DIRECTION('',(-0.939692620786,7.097592000379E-13, + -0.342020143326)); +#21714 = PCURVE('',#21331,#21715); +#21715 = DEFINITIONAL_REPRESENTATION('',(#21716),#21720); +#21716 = LINE('',#21717,#21718); +#21717 = CARTESIAN_POINT('',(26.883249401097,-7.641599237861)); +#21718 = VECTOR('',#21719,1.); +#21719 = DIRECTION('',(-0.342020143326,-0.939692620786)); +#21720 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21721 = PCURVE('',#21722,#21727); +#21722 = CYLINDRICAL_SURFACE('',#21723,10.); +#21723 = AXIS2_PLACEMENT_3D('',#21724,#21725,#21726); +#21724 = CARTESIAN_POINT('',(-87.11099203271,20.300000000046, + 70.062305864737)); +#21725 = DIRECTION('',(-0.939692620786,7.097592000379E-13, + -0.342020143326)); +#21726 = DIRECTION('',(-0.241844762647,0.707106781187,0.664463024389)); +#21727 = DEFINITIONAL_REPRESENTATION('',(#21728),#21732); +#21728 = LINE('',#21729,#21730); +#21729 = CARTESIAN_POINT('',(7.068583470577,-2.30926389122E-14)); +#21730 = VECTOR('',#21731,1.); +#21731 = DIRECTION('',(0.,1.)); +#21732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21733 = ORIENTED_EDGE('',*,*,#21734,.F.); +#21734 = EDGE_CURVE('',#21513,#21707,#21735,.T.); +#21735 = SURFACE_CURVE('',#21736,(#21740,#21747),.PCURVE_S1.); +#21736 = LINE('',#21737,#21738); +#21737 = CARTESIAN_POINT('',(-77.46321821206,30.300000000039, + 64.062415191825)); +#21738 = VECTOR('',#21739,1.); +#21739 = DIRECTION('',(-0.342020143326,2.592414618554E-13,0.939692620786 + )); +#21740 = PCURVE('',#21331,#21741); +#21741 = DEFINITIONAL_REPRESENTATION('',(#21742),#21746); +#21742 = LINE('',#21743,#21744); +#21743 = CARTESIAN_POINT('',(20.883358728186,2.006174582782)); +#21744 = VECTOR('',#21745,1.); +#21745 = DIRECTION('',(0.939692620786,-0.342020143326)); +#21746 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21747 = PCURVE('',#21554,#21748); +#21748 = DEFINITIONAL_REPRESENTATION('',(#21749),#21753); +#21749 = LINE('',#21750,#21751); +#21750 = CARTESIAN_POINT('',(18.937785975769,30.300000000033)); +#21751 = VECTOR('',#21752,1.); +#21752 = DIRECTION('',(-1.,2.461780094215E-13)); +#21753 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21754 = FACE_BOUND('',#21755,.T.); +#21755 = EDGE_LOOP('',(#21756)); +#21756 = ORIENTED_EDGE('',*,*,#21316,.T.); +#21757 = FACE_BOUND('',#21758,.T.); +#21758 = EDGE_LOOP('',(#21759)); +#21759 = ORIENTED_EDGE('',*,*,#21416,.T.); +#21760 = ADVANCED_FACE('',(#21761),#21500,.T.); +#21761 = FACE_BOUND('',#21762,.T.); +#21762 = EDGE_LOOP('',(#21763,#21764,#21787,#21810,#21838,#21866,#21894, + #21915)); +#21763 = ORIENTED_EDGE('',*,*,#21484,.F.); +#21764 = ORIENTED_EDGE('',*,*,#21765,.T.); +#21765 = EDGE_CURVE('',#21452,#21766,#21768,.T.); +#21766 = VERTEX_POINT('',#21767); +#21767 = CARTESIAN_POINT('',(-70.3,-30.30000000003,4.5)); +#21768 = SURFACE_CURVE('',#21769,(#21773,#21780),.PCURVE_S1.); +#21769 = LINE('',#21770,#21771); +#21770 = CARTESIAN_POINT('',(-70.3,-30.30000000003,23.83952823182)); +#21771 = VECTOR('',#21772,1.); +#21772 = DIRECTION('',(-2.277380563334E-16,-8.553453836234E-16,-1.)); +#21773 = PCURVE('',#21500,#21774); +#21774 = DEFINITIONAL_REPRESENTATION('',(#21775),#21779); +#21775 = LINE('',#21776,#21777); +#21776 = CARTESIAN_POINT('',(19.66047176818,-30.30000000003)); +#21777 = VECTOR('',#21778,1.); +#21778 = DIRECTION('',(1.,-8.553453836234E-16)); +#21779 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21780 = PCURVE('',#21136,#21781); +#21781 = DEFINITIONAL_REPRESENTATION('',(#21782),#21786); +#21782 = LINE('',#21783,#21784); +#21783 = CARTESIAN_POINT('',(19.33952823182,9.169392794851)); +#21784 = VECTOR('',#21785,1.); +#21785 = DIRECTION('',(1.,-2.277380563334E-16)); +#21786 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21787 = ORIENTED_EDGE('',*,*,#21788,.T.); +#21788 = EDGE_CURVE('',#21766,#21789,#21791,.T.); +#21789 = VERTEX_POINT('',#21790); +#21790 = CARTESIAN_POINT('',(-70.3,-18.30000000002,4.5)); +#21791 = SURFACE_CURVE('',#21792,(#21796,#21803),.PCURVE_S1.); +#21792 = LINE('',#21793,#21794); +#21793 = CARTESIAN_POINT('',(-70.3,5.057380536265E-12,4.5)); +#21794 = VECTOR('',#21795,1.); +#21795 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21796 = PCURVE('',#21500,#21797); +#21797 = DEFINITIONAL_REPRESENTATION('',(#21798),#21802); +#21798 = LINE('',#21799,#21800); +#21799 = CARTESIAN_POINT('',(39.,-5.525938212524E-115)); +#21800 = VECTOR('',#21801,1.); +#21801 = DIRECTION('',(-1.771134042476E-116,1.)); +#21802 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21803 = PCURVE('',#21609,#21804); +#21804 = DEFINITIONAL_REPRESENTATION('',(#21805),#21809); +#21805 = LINE('',#21806,#21807); +#21806 = CARTESIAN_POINT('',(23.650000000023,15.150000000014)); +#21807 = VECTOR('',#21808,1.); +#21808 = DIRECTION('',(-7.777066648374E-101,1.)); +#21809 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21810 = ORIENTED_EDGE('',*,*,#21811,.F.); +#21811 = EDGE_CURVE('',#21812,#21789,#21814,.T.); +#21812 = VERTEX_POINT('',#21813); +#21813 = CARTESIAN_POINT('',(-70.3,-18.30000000002,19.8)); +#21814 = SURFACE_CURVE('',#21815,(#21819,#21826),.PCURVE_S1.); +#21815 = LINE('',#21816,#21817); +#21816 = CARTESIAN_POINT('',(-70.3,-18.30000000002,19.8)); +#21817 = VECTOR('',#21818,1.); +#21818 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21819 = PCURVE('',#21500,#21820); +#21820 = DEFINITIONAL_REPRESENTATION('',(#21821),#21825); +#21821 = LINE('',#21822,#21823); +#21822 = CARTESIAN_POINT('',(23.7,-18.30000000003)); +#21823 = VECTOR('',#21824,1.); +#21824 = DIRECTION('',(1.,-8.553453836232E-16)); +#21825 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21826 = PCURVE('',#21827,#21832); +#21827 = PLANE('',#21828); +#21828 = AXIS2_PLACEMENT_3D('',#21829,#21830,#21831); +#21829 = CARTESIAN_POINT('',(-58.,-18.30000000002,19.8)); +#21830 = DIRECTION('',(-4.036126853609E-14,-1.,8.553453836232E-16)); +#21831 = DIRECTION('',(-1.,4.036126853609E-14,-2.012869368759E-30)); +#21832 = DEFINITIONAL_REPRESENTATION('',(#21833),#21837); +#21833 = LINE('',#21834,#21835); +#21834 = CARTESIAN_POINT('',(12.3,-2.323889461349E-29)); +#21835 = VECTOR('',#21836,1.); +#21836 = DIRECTION('',(1.599442196756E-31,1.)); +#21837 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21838 = ORIENTED_EDGE('',*,*,#21839,.T.); +#21839 = EDGE_CURVE('',#21812,#21840,#21842,.T.); +#21840 = VERTEX_POINT('',#21841); +#21841 = CARTESIAN_POINT('',(-70.3,18.300000000025,19.8)); +#21842 = SURFACE_CURVE('',#21843,(#21847,#21854),.PCURVE_S1.); +#21843 = LINE('',#21844,#21845); +#21844 = CARTESIAN_POINT('',(-70.3,-30.30000000003,19.8)); +#21845 = VECTOR('',#21846,1.); +#21846 = DIRECTION('',(3.497056960303E-14,1.,-8.553453836232E-16)); +#21847 = PCURVE('',#21500,#21848); +#21848 = DEFINITIONAL_REPRESENTATION('',(#21849),#21853); +#21849 = LINE('',#21850,#21851); +#21850 = CARTESIAN_POINT('',(23.7,-30.30000000003)); +#21851 = VECTOR('',#21852,1.); +#21852 = DIRECTION('',(8.553453836232E-16,1.)); +#21853 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21854 = PCURVE('',#21855,#21860); +#21855 = PLANE('',#21856); +#21856 = AXIS2_PLACEMENT_3D('',#21857,#21858,#21859); +#21857 = CARTESIAN_POINT('',(-46.64999999997,-15.15000000001,19.8)); +#21858 = DIRECTION('',(-3.250995535076E-29,-8.553453836232E-16,-1.)); +#21859 = DIRECTION('',(1.,-3.819497970755E-14,1.599442196756E-31)); +#21860 = DEFINITIONAL_REPRESENTATION('',(#21861),#21865); +#21861 = LINE('',#21862,#21863); +#21862 = CARTESIAN_POINT('',(-23.65000000002,15.150000000024)); +#21863 = VECTOR('',#21864,1.); +#21864 = DIRECTION('',(-3.224410104518E-15,-1.)); +#21865 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21866 = ORIENTED_EDGE('',*,*,#21867,.T.); +#21867 = EDGE_CURVE('',#21840,#21868,#21870,.T.); +#21868 = VERTEX_POINT('',#21869); +#21869 = CARTESIAN_POINT('',(-70.3,18.300000000025,4.5)); +#21870 = SURFACE_CURVE('',#21871,(#21875,#21882),.PCURVE_S1.); +#21871 = LINE('',#21872,#21873); +#21872 = CARTESIAN_POINT('',(-70.3,18.300000000025,19.8)); +#21873 = VECTOR('',#21874,1.); +#21874 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#21875 = PCURVE('',#21500,#21876); +#21876 = DEFINITIONAL_REPRESENTATION('',(#21877),#21881); +#21877 = LINE('',#21878,#21879); +#21878 = CARTESIAN_POINT('',(23.7,18.30000000002)); +#21879 = VECTOR('',#21880,1.); +#21880 = DIRECTION('',(1.,-8.553453836232E-16)); +#21881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21882 = PCURVE('',#21883,#21888); +#21883 = PLANE('',#21884); +#21884 = AXIS2_PLACEMENT_3D('',#21885,#21886,#21887); +#21885 = CARTESIAN_POINT('',(-58.,18.300000000026,19.8)); +#21886 = DIRECTION('',(4.036620265772E-14,-1.,8.553453836232E-16)); +#21887 = DIRECTION('',(-1.,-4.036620265772E-14,6.703700044843E-29)); +#21888 = DEFINITIONAL_REPRESENTATION('',(#21889),#21893); +#21889 = LINE('',#21890,#21891); +#21890 = CARTESIAN_POINT('',(12.3,8.245855366012E-28)); +#21891 = VECTOR('',#21892,1.); +#21892 = DIRECTION('',(1.599442196756E-31,1.)); +#21893 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21894 = ORIENTED_EDGE('',*,*,#21895,.T.); +#21895 = EDGE_CURVE('',#21868,#21571,#21896,.T.); +#21896 = SURFACE_CURVE('',#21897,(#21901,#21908),.PCURVE_S1.); +#21897 = LINE('',#21898,#21899); +#21898 = CARTESIAN_POINT('',(-70.3,5.057380536265E-12,4.5)); +#21899 = VECTOR('',#21900,1.); +#21900 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#21901 = PCURVE('',#21500,#21902); +#21902 = DEFINITIONAL_REPRESENTATION('',(#21903),#21907); +#21903 = LINE('',#21904,#21905); +#21904 = CARTESIAN_POINT('',(39.,-5.525938212524E-115)); +#21905 = VECTOR('',#21906,1.); +#21906 = DIRECTION('',(-1.771134042476E-116,1.)); +#21907 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21908 = PCURVE('',#21609,#21909); +#21909 = DEFINITIONAL_REPRESENTATION('',(#21910),#21914); +#21910 = LINE('',#21911,#21912); +#21911 = CARTESIAN_POINT('',(23.650000000023,15.150000000014)); +#21912 = VECTOR('',#21913,1.); +#21913 = DIRECTION('',(-7.777066648374E-101,1.)); +#21914 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21915 = ORIENTED_EDGE('',*,*,#21570,.T.); +#21916 = ADVANCED_FACE('',(#21917,#22063,#22066),#21136,.T.); +#21917 = FACE_BOUND('',#21918,.T.); +#21918 = EDGE_LOOP('',(#21919,#21920,#21943,#21971,#21994,#22018,#22041, + #22062)); +#21919 = ORIENTED_EDGE('',*,*,#21449,.F.); +#21920 = ORIENTED_EDGE('',*,*,#21921,.F.); +#21921 = EDGE_CURVE('',#21922,#21450,#21924,.T.); +#21922 = VERTEX_POINT('',#21923); +#21923 = CARTESIAN_POINT('',(-80.52012105251,-30.30000000004, + 72.461186719417)); +#21924 = SURFACE_CURVE('',#21925,(#21929,#21936),.PCURVE_S1.); +#21925 = LINE('',#21926,#21927); +#21926 = CARTESIAN_POINT('',(-70.79382541722,-30.30000000003, + 45.7384090865)); +#21927 = VECTOR('',#21928,1.); +#21928 = DIRECTION('',(0.342020143326,2.57635625934E-13,-0.939692620786) + ); +#21929 = PCURVE('',#21136,#21930); +#21930 = DEFINITIONAL_REPRESENTATION('',(#21931),#21935); +#21931 = LINE('',#21932,#21933); +#21932 = CARTESIAN_POINT('',(-2.559352622861,8.675567377633)); +#21933 = VECTOR('',#21934,1.); +#21934 = DIRECTION('',(0.939692620786,0.342020143326)); +#21935 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21936 = PCURVE('',#21554,#21937); +#21937 = DEFINITIONAL_REPRESENTATION('',(#21938),#21942); +#21938 = LINE('',#21939,#21940); +#21939 = CARTESIAN_POINT('',(38.43778597577,-30.30000000003)); +#21940 = VECTOR('',#21941,1.); +#21941 = DIRECTION('',(1.,2.706990783679E-13)); +#21942 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21943 = ORIENTED_EDGE('',*,*,#21944,.F.); +#21944 = EDGE_CURVE('',#21945,#21922,#21947,.T.); +#21945 = VERTEX_POINT('',#21946); +#21946 = CARTESIAN_POINT('',(-85.21858415644,-30.30000000004, + 70.751086002788)); +#21947 = SURFACE_CURVE('',#21948,(#21952,#21959),.PCURVE_S1.); +#21948 = LINE('',#21949,#21950); +#21949 = CARTESIAN_POINT('',(-87.11099203271,-30.30000000004, + 70.062305864737)); +#21950 = VECTOR('',#21951,1.); +#21951 = DIRECTION('',(0.939692620786,7.103489272969E-13,0.342020143326) + ); +#21952 = PCURVE('',#21136,#21953); +#21953 = DEFINITIONAL_REPRESENTATION('',(#21954),#21958); +#21954 = LINE('',#21955,#21956); +#21955 = CARTESIAN_POINT('',(-26.88324940109,-7.641599237859)); +#21956 = VECTOR('',#21957,1.); +#21957 = DIRECTION('',(-0.342020143326,0.939692620786)); +#21958 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21959 = PCURVE('',#21960,#21965); +#21960 = CYLINDRICAL_SURFACE('',#21961,10.); +#21961 = AXIS2_PLACEMENT_3D('',#21962,#21963,#21964); +#21962 = CARTESIAN_POINT('',(-87.11099203272,-20.30000000004, + 70.062305864737)); +#21963 = DIRECTION('',(0.939692620786,7.103489272969E-13,0.342020143326) + ); +#21964 = DIRECTION('',(-0.241844762647,-0.707106781187,0.664463024389)); +#21965 = DEFINITIONAL_REPRESENTATION('',(#21966),#21970); +#21966 = LINE('',#21967,#21968); +#21967 = CARTESIAN_POINT('',(0.785398163398,6.483702463811E-14)); +#21968 = VECTOR('',#21969,1.); +#21969 = DIRECTION('',(0.,1.)); +#21970 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21971 = ORIENTED_EDGE('',*,*,#21972,.F.); +#21972 = EDGE_CURVE('',#21973,#21945,#21975,.T.); +#21973 = VERTEX_POINT('',#21974); +#21974 = CARTESIAN_POINT('',(-77.71229516856,-30.30000000003, + 50.127726504689)); +#21975 = SURFACE_CURVE('',#21976,(#21980,#21987),.PCURVE_S1.); +#21976 = LINE('',#21977,#21978); +#21977 = CARTESIAN_POINT('',(-82.161681316,-30.30000000004, + 62.352314475197)); +#21978 = VECTOR('',#21979,1.); +#21979 = DIRECTION('',(-0.342020143326,-2.57635625934E-13,0.939692620786 + )); +#21980 = PCURVE('',#21136,#21981); +#21981 = DEFINITIONAL_REPRESENTATION('',(#21982),#21986); +#21982 = LINE('',#21983,#21984); +#21983 = CARTESIAN_POINT('',(-19.17325801155,-2.692288521147)); +#21984 = VECTOR('',#21985,1.); +#21985 = DIRECTION('',(-0.939692620786,-0.342020143326)); +#21986 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21987 = PCURVE('',#21694,#21988); +#21988 = DEFINITIONAL_REPRESENTATION('',(#21989),#21993); +#21989 = LINE('',#21990,#21991); +#21990 = CARTESIAN_POINT('',(20.06221402423,-30.30000000004)); +#21991 = VECTOR('',#21992,1.); +#21992 = DIRECTION('',(1.,-2.706990783679E-13)); +#21993 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#21994 = ORIENTED_EDGE('',*,*,#21995,.F.); +#21995 = EDGE_CURVE('',#21996,#21973,#21998,.T.); +#21996 = VERTEX_POINT('',#21997); +#21997 = CARTESIAN_POINT('',(-75.3,-30.30000000003,36.446920771661)); +#21998 = SURFACE_CURVE('',#21999,(#22004,#22011),.PCURVE_S1.); +#21999 = CIRCLE('',#22000,40.); +#22000 = AXIS2_PLACEMENT_3D('',#22001,#22002,#22003); +#22001 = CARTESIAN_POINT('',(-115.3,-30.30000000003,36.446920771661)); +#22002 = DIRECTION('',(7.556262188718E-13,-1.,8.553453836232E-16)); +#22003 = DIRECTION('',(0.984807753012,7.442950878914E-13,0.173648177667) + ); +#22004 = PCURVE('',#21136,#22005); +#22005 = DEFINITIONAL_REPRESENTATION('',(#22006),#22010); +#22006 = CIRCLE('',#22007,40.); +#22007 = AXIS2_PLACEMENT_2D('',#22008,#22009); +#22008 = CARTESIAN_POINT('',(6.732135691978,-35.83060720514)); +#22009 = DIRECTION('',(-0.173648177667,0.984807753012)); +#22010 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22011 = PCURVE('',#21666,#22012); +#22012 = DEFINITIONAL_REPRESENTATION('',(#22013),#22017); +#22013 = LINE('',#22014,#22015); +#22014 = CARTESIAN_POINT('',(-6.28318530718,30.29999999998)); +#22015 = VECTOR('',#22016,1.); +#22016 = DIRECTION('',(1.,5.455287389646E-12)); +#22017 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22018 = ORIENTED_EDGE('',*,*,#22019,.F.); +#22019 = EDGE_CURVE('',#22020,#21996,#22022,.T.); +#22020 = VERTEX_POINT('',#22021); +#22021 = CARTESIAN_POINT('',(-75.3,-30.30000000003,4.5)); +#22022 = SURFACE_CURVE('',#22023,(#22027,#22034),.PCURVE_S1.); +#22023 = LINE('',#22024,#22025); +#22024 = CARTESIAN_POINT('',(-75.3,-30.30000000003,43.33952823182)); +#22025 = VECTOR('',#22026,1.); +#22026 = DIRECTION('',(7.970831971668E-16,8.553453836238E-16,1.)); +#22027 = PCURVE('',#21136,#22028); +#22028 = DEFINITIONAL_REPRESENTATION('',(#22029),#22033); +#22029 = LINE('',#22030,#22031); +#22030 = CARTESIAN_POINT('',(-0.16047176818,4.169392794851)); +#22031 = VECTOR('',#22032,1.); +#22032 = DIRECTION('',(-1.,7.970831971668E-16)); +#22033 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22034 = PCURVE('',#21637,#22035); +#22035 = DEFINITIONAL_REPRESENTATION('',(#22036),#22040); +#22036 = LINE('',#22037,#22038); +#22037 = CARTESIAN_POINT('',(38.83952823182,-30.30000000004)); +#22038 = VECTOR('',#22039,1.); +#22039 = DIRECTION('',(1.,8.553453836238E-16)); +#22040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22041 = ORIENTED_EDGE('',*,*,#22042,.F.); +#22042 = EDGE_CURVE('',#21766,#22020,#22043,.T.); +#22043 = SURFACE_CURVE('',#22044,(#22048,#22055),.PCURVE_S1.); +#22044 = LINE('',#22045,#22046); +#22045 = CARTESIAN_POINT('',(-77.38469639741,-30.30000000003,4.5)); +#22046 = VECTOR('',#22047,1.); +#22047 = DIRECTION('',(-1.,-7.556262188718E-13,2.24207754292E-44)); +#22048 = PCURVE('',#21136,#22049); +#22049 = DEFINITIONAL_REPRESENTATION('',(#22050),#22054); +#22050 = LINE('',#22051,#22052); +#22051 = CARTESIAN_POINT('',(38.679056463639,2.084696397438)); +#22052 = VECTOR('',#22053,1.); +#22053 = DIRECTION('',(6.789912976271E-28,-1.)); +#22054 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22055 = PCURVE('',#21609,#22056); +#22056 = DEFINITIONAL_REPRESENTATION('',(#22057),#22061); +#22057 = LINE('',#22058,#22059); +#22058 = CARTESIAN_POINT('',(30.734696397436,-15.15000000003)); +#22059 = VECTOR('',#22060,1.); +#22060 = DIRECTION('',(1.,-7.938211985794E-13)); +#22061 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22062 = ORIENTED_EDGE('',*,*,#21765,.F.); +#22063 = FACE_BOUND('',#22064,.T.); +#22064 = EDGE_LOOP('',(#22065)); +#22065 = ORIENTED_EDGE('',*,*,#21121,.T.); +#22066 = FACE_BOUND('',#22067,.T.); +#22067 = EDGE_LOOP('',(#22068)); +#22068 = ORIENTED_EDGE('',*,*,#21221,.T.); +#22069 = ADVANCED_FACE('',(#22070),#21666,.F.); +#22070 = FACE_BOUND('',#22071,.F.); +#22071 = EDGE_LOOP('',(#22072,#22093,#22094,#22115)); +#22072 = ORIENTED_EDGE('',*,*,#22073,.F.); +#22073 = EDGE_CURVE('',#21973,#21650,#22074,.T.); +#22074 = SURFACE_CURVE('',#22075,(#22079,#22086),.PCURVE_S1.); +#22075 = LINE('',#22076,#22077); +#22076 = CARTESIAN_POINT('',(-77.71229516856,5.340492999815E-12, + 50.127726504689)); +#22077 = VECTOR('',#22078,1.); +#22078 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22079 = PCURVE('',#21666,#22080); +#22080 = DEFINITIONAL_REPRESENTATION('',(#22081),#22085); +#22081 = LINE('',#22082,#22083); +#22082 = CARTESIAN_POINT('',(0.174532925199,0.)); +#22083 = VECTOR('',#22084,1.); +#22084 = DIRECTION('',(0.,-1.)); +#22085 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22086 = PCURVE('',#21694,#22087); +#22087 = DEFINITIONAL_REPRESENTATION('',(#22088),#22092); +#22088 = LINE('',#22089,#22090); +#22089 = CARTESIAN_POINT('',(7.053079228339,-9.380290150736E-101)); +#22090 = VECTOR('',#22091,1.); +#22091 = DIRECTION('',(-2.65991344973E-101,1.)); +#22092 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22093 = ORIENTED_EDGE('',*,*,#21995,.F.); +#22094 = ORIENTED_EDGE('',*,*,#22095,.F.); +#22095 = EDGE_CURVE('',#21622,#21996,#22096,.T.); +#22096 = SURFACE_CURVE('',#22097,(#22101,#22108),.PCURVE_S1.); +#22097 = LINE('',#22098,#22099); +#22098 = CARTESIAN_POINT('',(-75.3,5.248355434803E-12,36.446920771661)); +#22099 = VECTOR('',#22100,1.); +#22100 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#22101 = PCURVE('',#21666,#22102); +#22102 = DEFINITIONAL_REPRESENTATION('',(#22103),#22107); +#22103 = LINE('',#22104,#22105); +#22104 = CARTESIAN_POINT('',(-0.174532925199,0.)); +#22105 = VECTOR('',#22106,1.); +#22106 = DIRECTION('',(0.,1.)); +#22107 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22108 = PCURVE('',#21637,#22109); +#22109 = DEFINITIONAL_REPRESENTATION('',(#22110),#22114); +#22110 = LINE('',#22111,#22112); +#22111 = CARTESIAN_POINT('',(31.946920771661,1.105187642505E-114)); +#22112 = VECTOR('',#22113,1.); +#22113 = DIRECTION('',(-6.198969148665E-116,-1.)); +#22114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22115 = ORIENTED_EDGE('',*,*,#21649,.F.); +#22116 = ADVANCED_FACE('',(#22117),#21637,.T.); +#22117 = FACE_BOUND('',#22118,.T.); +#22118 = EDGE_LOOP('',(#22119,#22120,#22121,#22142)); +#22119 = ORIENTED_EDGE('',*,*,#22095,.F.); +#22120 = ORIENTED_EDGE('',*,*,#21621,.T.); +#22121 = ORIENTED_EDGE('',*,*,#22122,.F.); +#22122 = EDGE_CURVE('',#22020,#21594,#22123,.T.); +#22123 = SURFACE_CURVE('',#22124,(#22128,#22135),.PCURVE_S1.); +#22124 = LINE('',#22125,#22126); +#22125 = CARTESIAN_POINT('',(-75.3,5.248355434803E-12,4.5)); +#22126 = VECTOR('',#22127,1.); +#22127 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22128 = PCURVE('',#21637,#22129); +#22129 = DEFINITIONAL_REPRESENTATION('',(#22130),#22134); +#22130 = LINE('',#22131,#22132); +#22131 = CARTESIAN_POINT('',(0.,0.)); +#22132 = VECTOR('',#22133,1.); +#22133 = DIRECTION('',(6.198969148665E-116,1.)); +#22134 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22135 = PCURVE('',#21609,#22136); +#22136 = DEFINITIONAL_REPRESENTATION('',(#22137),#22141); +#22137 = LINE('',#22138,#22139); +#22138 = CARTESIAN_POINT('',(28.650000000023,15.150000000014)); +#22139 = VECTOR('',#22140,1.); +#22140 = DIRECTION('',(-7.777066648374E-101,1.)); +#22141 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22142 = ORIENTED_EDGE('',*,*,#22019,.T.); +#22143 = ADVANCED_FACE('',(#22144),#21722,.T.); +#22144 = FACE_BOUND('',#22145,.T.); +#22145 = EDGE_LOOP('',(#22146,#22176,#22255,#22281,#22282,#22310)); +#22146 = ORIENTED_EDGE('',*,*,#22147,.T.); +#22147 = EDGE_CURVE('',#22148,#22150,#22152,.T.); +#22148 = VERTEX_POINT('',#22149); +#22149 = CARTESIAN_POINT('',(-86.75940034813,20.300000000043, + 80.832052497301)); +#22150 = VERTEX_POINT('',#22151); +#22151 = CARTESIAN_POINT('',(-85.81970772734,20.300000000042, + 81.174072640627)); +#22152 = SURFACE_CURVE('',#22153,(#22157,#22164),.PCURVE_S1.); +#22153 = LINE('',#22154,#22155); +#22154 = CARTESIAN_POINT('',(-90.53119346597,20.300000000046, + 79.459232072596)); +#22155 = VECTOR('',#22156,1.); +#22156 = DIRECTION('',(0.939692620786,-7.097592000379E-13,0.342020143326 + )); +#22157 = PCURVE('',#21722,#22158); +#22158 = DEFINITIONAL_REPRESENTATION('',(#22159),#22163); +#22159 = LINE('',#22160,#22161); +#22160 = CARTESIAN_POINT('',(5.497787143782,1.50990331349E-14)); +#22161 = VECTOR('',#22162,1.); +#22162 = DIRECTION('',(0.,-1.)); +#22163 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22164 = PCURVE('',#22165,#22170); +#22165 = PLANE('',#22166); +#22166 = AXIS2_PLACEMENT_3D('',#22167,#22168,#22169); +#22167 = CARTESIAN_POINT('',(-88.6387855897,5.757830079725E-12, + 80.14801221065)); +#22168 = DIRECTION('',(-0.342020143326,1.30634524339E-14,0.939692620786) + ); +#22169 = DIRECTION('',(0.939692620786,-3.589154058225E-14,0.342020143326 + )); +#22170 = DEFINITIONAL_REPRESENTATION('',(#22171),#22175); +#22171 = LINE('',#22172,#22173); +#22172 = CARTESIAN_POINT('',(-2.013858398388,20.30000000004)); +#22173 = VECTOR('',#22174,1.); +#22174 = DIRECTION('',(1.,-6.738676594556E-13)); +#22175 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22176 = ORIENTED_EDGE('',*,*,#22177,.T.); +#22177 = EDGE_CURVE('',#22150,#22178,#22180,.T.); +#22178 = VERTEX_POINT('',#22179); +#22179 = CARTESIAN_POINT('',(-83.25628219912,26.300000000041, + 79.978727685707)); +#22180 = SURFACE_CURVE('',#22181,(#22192,#22221),.PCURVE_S1.); +#22181 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22182,#22183,#22184,#22185, + #22186,#22187,#22188,#22189,#22190,#22191),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.475998478483E-03,0.,0.244637728188,0.486936605506, + 0.699278564471),.UNSPECIFIED.); +#22182 = CARTESIAN_POINT('',(-85.81970772734,20.300000000042, + 81.174072640627)); +#22183 = CARTESIAN_POINT('',(-85.81782027999,20.304491320384, + 81.174759615282)); +#22184 = CARTESIAN_POINT('',(-85.8159317974,20.308982641574, + 81.17544374675)); +#22185 = CARTESIAN_POINT('',(-85.50086731687,21.05788263613, + 81.28904401413)); +#22186 = CARTESIAN_POINT('',(-85.15768066333,21.805379708828, + 81.324424518638)); +#22187 = CARTESIAN_POINT('',(-84.47617672161,23.270630122588, + 81.213827770463)); +#22188 = CARTESIAN_POINT('',(-84.1325594034,23.996802517318, + 81.068733101663)); +#22189 = CARTESIAN_POINT('',(-83.57418327147,25.305480104474, + 80.590692616289)); +#22190 = CARTESIAN_POINT('',(-83.37438276909,25.839596045163, + 80.303206334941)); +#22191 = CARTESIAN_POINT('',(-83.25628219912,26.300000000041, + 79.978727685707)); +#22192 = PCURVE('',#21722,#22193); +#22193 = DEFINITIONAL_REPRESENTATION('',(#22194),#22220); +#22194 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22195,#22196,#22197,#22198, + #22199,#22200,#22201,#22202,#22203,#22204,#22205,#22206,#22207, + #22208,#22209,#22210,#22211,#22212,#22213,#22214,#22215,#22216, + #22217,#22218,#22219),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.475998478483E-03,3.03764816556E-02, + 6.222896178968E-02,9.408144192376E-02,0.125933922058,0.157786402192, + 0.189638882326,0.22149136246,0.253343842594,0.285196322728, + 0.317048802862,0.348901282996,0.380753763131,0.412606243265, + 0.444458723399,0.476311203533,0.508163683667,0.540016163801, + 0.571868643935,0.603721124069,0.635573604203,0.667426084337, + 0.699278564471),.UNSPECIFIED.); +#22195 = CARTESIAN_POINT('',(5.497787143782,-5.013858398388)); +#22196 = CARTESIAN_POINT('',(5.507479087257,-5.057201325199)); +#22197 = CARTESIAN_POINT('',(5.526873658173,-5.143950941442)); +#22198 = CARTESIAN_POINT('',(5.55600334047,-5.273822636515)); +#22199 = CARTESIAN_POINT('',(5.585176590577,-5.402997860158)); +#22200 = CARTESIAN_POINT('',(5.614399262871,-5.531031907693)); +#22201 = CARTESIAN_POINT('',(5.64367793724,-5.657482428054)); +#22202 = CARTESIAN_POINT('',(5.67301773181,-5.781898618268)); +#22203 = CARTESIAN_POINT('',(5.702430632229,-5.903861129373)); +#22204 = CARTESIAN_POINT('',(5.731904543791,-6.022833248272)); +#22205 = CARTESIAN_POINT('',(5.761538546308,-6.138818916785)); +#22206 = CARTESIAN_POINT('',(5.791335962055,-6.251116431275)); +#22207 = CARTESIAN_POINT('',(5.821287018295,-6.35897737015)); +#22208 = CARTESIAN_POINT('',(5.851385842111,-6.461664689912)); +#22209 = CARTESIAN_POINT('',(5.881627459099,-6.558442552647)); +#22210 = CARTESIAN_POINT('',(5.912003704427,-6.648558920015)); +#22211 = CARTESIAN_POINT('',(5.942523470288,-6.731325349788)); +#22212 = CARTESIAN_POINT('',(5.973136678443,-6.805815215724)); +#22213 = CARTESIAN_POINT('',(6.002913379161,-6.869046778582)); +#22214 = CARTESIAN_POINT('',(6.032031089007,-6.921344818002)); +#22215 = CARTESIAN_POINT('',(6.060440460949,-6.962361700319)); +#22216 = CARTESIAN_POINT('',(6.088148410833,-6.991929968916)); +#22217 = CARTESIAN_POINT('',(6.115142762178,-7.009833872296)); +#22218 = CARTESIAN_POINT('',(6.132655097648,-7.013858398384)); +#22219 = CARTESIAN_POINT('',(6.141288252575,-7.013858398384)); +#22220 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22221 = PCURVE('',#22222,#22227); +#22222 = CYLINDRICAL_SURFACE('',#22223,2.); +#22223 = AXIS2_PLACEMENT_3D('',#22224,#22225,#22226); +#22224 = CARTESIAN_POINT('',(-85.13566744069,5.624028553111E-12, + 79.294687399055)); +#22225 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22226 = DIRECTION('',(0.422618261741,-1.614189593123E-14,0.906307787037 + )); +#22227 = DEFINITIONAL_REPRESENTATION('',(#22228),#22254); +#22228 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22229,#22230,#22231,#22232, + #22233,#22234,#22235,#22236,#22237,#22238,#22239,#22240,#22241, + #22242,#22243,#22244,#22245,#22246,#22247,#22248,#22249,#22250, + #22251,#22252,#22253),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.475998478483E-03,3.03764816556E-02, + 6.222896178968E-02,9.408144192376E-02,0.125933922058,0.157786402192, + 0.189638882326,0.22149136246,0.253343842594,0.285196322728, + 0.317048802862,0.348901282996,0.380753763131,0.412606243265, + 0.444458723399,0.476311203533,0.508163683667,0.540016163801, + 0.571868643935,0.603721124069,0.635573604203,0.667426084337, + 0.699278564471),.UNSPECIFIED.); +#22229 = CARTESIAN_POINT('',(-0.785398163397,20.300000000037)); +#22230 = CARTESIAN_POINT('',(-0.763726371186,20.396919270671)); +#22231 = CARTESIAN_POINT('',(-0.720352090641,20.590865264634)); +#22232 = CARTESIAN_POINT('',(-0.655140597415,20.881915571688)); +#22233 = CARTESIAN_POINT('',(-0.589722967112,21.172906668236)); +#22234 = CARTESIAN_POINT('',(-0.524036417263,21.463646223917)); +#22235 = CARTESIAN_POINT('',(-0.458009310445,21.753946543938)); +#22236 = CARTESIAN_POINT('',(-0.39156519998,22.043603194982)); +#22237 = CARTESIAN_POINT('',(-0.324597678685,22.332474062263)); +#22238 = CARTESIAN_POINT('',(-0.257057693739,22.620184495392)); +#22239 = CARTESIAN_POINT('',(-0.188563035179,22.907415026728)); +#22240 = CARTESIAN_POINT('',(-0.119080603881,23.193915024246)); +#22241 = CARTESIAN_POINT('',(-4.857752405171E-02,23.479306596387)); +#22242 = CARTESIAN_POINT('',(2.302213163495E-02,23.763243140059)); +#22243 = CARTESIAN_POINT('',(9.583355355544E-02,24.045380157839)); +#22244 = CARTESIAN_POINT('',(0.170003743779,24.325333441162)); +#22245 = CARTESIAN_POINT('',(0.245757230087,24.602875520361)); +#22246 = CARTESIAN_POINT('',(0.323222042989,24.877191681321)); +#22247 = CARTESIAN_POINT('',(0.400101594832,25.139881193733)); +#22248 = CARTESIAN_POINT('',(0.476961059964,25.392613207721)); +#22249 = CARTESIAN_POINT('',(0.553786354623,25.635027667375)); +#22250 = CARTESIAN_POINT('',(0.63071713605,25.86730825431)); +#22251 = CARTESIAN_POINT('',(0.707854602667,26.089492906066)); +#22252 = CARTESIAN_POINT('',(0.759500407348,26.230936834668)); +#22253 = CARTESIAN_POINT('',(0.785398163397,26.300000000035)); +#22254 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22255 = ORIENTED_EDGE('',*,*,#22256,.T.); +#22256 = EDGE_CURVE('',#22178,#21707,#22257,.T.); +#22257 = SURFACE_CURVE('',#22258,(#22263,#22270),.PCURVE_S1.); +#22258 = CIRCLE('',#22259,10.); +#22259 = AXIS2_PLACEMENT_3D('',#22260,#22261,#22262); +#22260 = CARTESIAN_POINT('',(-80.5201210525,20.300000000041, + 72.461186719424)); +#22261 = DIRECTION('',(-0.939692620786,3.587060603976E-14, + -0.342020143326)); +#22262 = DIRECTION('',(-0.241844762648,0.707106781187,0.664463024389)); +#22263 = PCURVE('',#21722,#22264); +#22264 = DEFINITIONAL_REPRESENTATION('',(#22265),#22269); +#22265 = LINE('',#22266,#22267); +#22266 = CARTESIAN_POINT('',(8.881784197001E-16,-7.013858398414)); +#22267 = VECTOR('',#22268,1.); +#22268 = DIRECTION('',(1.,2.727860653435E-12)); +#22269 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22270 = PCURVE('',#21554,#22271); +#22271 = DEFINITIONAL_REPRESENTATION('',(#22272),#22280); +#22272 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#22273,#22274,#22275,#22276 + ,#22277,#22278,#22279),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#22273 = CARTESIAN_POINT('',(2.928932188135,27.371067811902)); +#22274 = CARTESIAN_POINT('',(15.176380902053,39.618516525816)); +#22275 = CARTESIAN_POINT('',(19.659258262891,22.88819045106)); +#22276 = CARTESIAN_POINT('',(24.142135623729,6.157864376303)); +#22277 = CARTESIAN_POINT('',(7.411809548974,10.640741737145)); +#22278 = CARTESIAN_POINT('',(-9.318516525782,15.123619097987)); +#22279 = CARTESIAN_POINT('',(2.928932188135,27.371067811902)); +#22280 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22281 = ORIENTED_EDGE('',*,*,#21706,.T.); +#22282 = ORIENTED_EDGE('',*,*,#22283,.T.); +#22283 = EDGE_CURVE('',#21679,#22284,#22286,.T.); +#22284 = VERTEX_POINT('',#22285); +#22285 = CARTESIAN_POINT('',(-87.95474530305,26.300000000045, + 78.268626969078)); +#22286 = SURFACE_CURVE('',#22287,(#22292,#22299),.PCURVE_S1.); +#22287 = CIRCLE('',#22288,10.); +#22288 = AXIS2_PLACEMENT_3D('',#22289,#22290,#22291); +#22289 = CARTESIAN_POINT('',(-85.21858415643,20.300000000044, + 70.751086002796)); +#22290 = DIRECTION('',(0.939692620786,-3.587271431189E-14,0.342020143326 + )); +#22291 = DIRECTION('',(-0.241844762648,0.707106781187,0.664463024389)); +#22292 = PCURVE('',#21722,#22293); +#22293 = DEFINITIONAL_REPRESENTATION('',(#22294),#22298); +#22294 = LINE('',#22295,#22296); +#22295 = CARTESIAN_POINT('',(12.566370614359,-2.013858398383)); +#22296 = VECTOR('',#22297,1.); +#22297 = DIRECTION('',(-1.,-2.574610054928E-12)); +#22298 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22299 = PCURVE('',#21694,#22300); +#22300 = DEFINITIONAL_REPRESENTATION('',(#22301),#22309); +#22301 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#22302,#22303,#22304,#22305 + ,#22306,#22307,#22308),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#22302 = CARTESIAN_POINT('',(36.071067811865,27.371067811905)); +#22303 = CARTESIAN_POINT('',(48.318516525782,15.123619097991)); +#22304 = CARTESIAN_POINT('',(31.588190451026,10.640741737148)); +#22305 = CARTESIAN_POINT('',(14.857864376271,6.157864376306)); +#22306 = CARTESIAN_POINT('',(19.340741737109,22.888190451063)); +#22307 = CARTESIAN_POINT('',(23.823619097947,39.61851652582)); +#22308 = CARTESIAN_POINT('',(36.071067811865,27.371067811905)); +#22309 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22310 = ORIENTED_EDGE('',*,*,#22311,.T.); +#22311 = EDGE_CURVE('',#22284,#22148,#22312,.T.); +#22312 = SURFACE_CURVE('',#22313,(#22324,#22353),.PCURVE_S1.); +#22313 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22314,#22315,#22316,#22317, + #22318,#22319,#22320,#22321,#22322,#22323),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(0.,0.172651483079,0.369660405483,0.56857100607, + 0.56977111427),.UNSPECIFIED.); +#22314 = CARTESIAN_POINT('',(-87.95474530305,26.300000000045, + 78.268626969078)); +#22315 = CARTESIAN_POINT('',(-88.07284587302,25.839596045168, + 78.593105618312)); +#22316 = CARTESIAN_POINT('',(-88.10458242805,25.30548010448, + 78.941762173948)); +#22317 = CARTESIAN_POINT('',(-87.98411999594,23.996802517321, + 79.666879690503)); +#22318 = CARTESIAN_POINT('',(-87.8141589141,23.27063012259, + 79.998901609888)); +#22319 = CARTESIAN_POINT('',(-87.36318682599,21.805379708845, + 80.521685923935)); +#22320 = CARTESIAN_POINT('',(-87.07754844726,21.057882636533, + 80.715179013737)); +#22321 = CARTESIAN_POINT('',(-86.7631742083,20.308982641571, + 80.830675704546)); +#22322 = CARTESIAN_POINT('',(-86.76128779548,20.304491320385, + 80.831365522647)); +#22323 = CARTESIAN_POINT('',(-86.75940034813,20.300000000043, + 80.832052497301)); +#22324 = PCURVE('',#21722,#22325); +#22325 = DEFINITIONAL_REPRESENTATION('',(#22326),#22352); +#22326 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22327,#22328,#22329,#22330, + #22331,#22332,#22333,#22334,#22335,#22336,#22337,#22338,#22339, + #22340,#22341,#22342,#22343,#22344,#22345,#22346,#22347,#22348, + #22349,#22350,#22351),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,2.589868701229E-02,5.179737402458E-02, + 7.769606103687E-02,0.103594748049,0.129493435061,0.155392122074, + 0.181290809086,0.207189496098,0.233088183111,0.258986870123, + 0.284885557135,0.310784244147,0.33668293116,0.362581618172, + 0.388480305184,0.414378992197,0.440277679209,0.466176366221, + 0.492075053234,0.517973740246,0.543872427258,0.56977111427), + .QUASI_UNIFORM_KNOTS.); +#22327 = CARTESIAN_POINT('',(6.141288252575,-2.013858398384)); +#22328 = CARTESIAN_POINT('',(6.132655097649,-2.013858398384)); +#22329 = CARTESIAN_POINT('',(6.115142762178,-2.017882924473)); +#22330 = CARTESIAN_POINT('',(6.088148410833,-2.035786827853)); +#22331 = CARTESIAN_POINT('',(6.06044046095,-2.065355096449)); +#22332 = CARTESIAN_POINT('',(6.032031089009,-2.106371978766)); +#22333 = CARTESIAN_POINT('',(6.002913379163,-2.158670018185)); +#22334 = CARTESIAN_POINT('',(5.973136678445,-2.221901581042)); +#22335 = CARTESIAN_POINT('',(5.94252347029,-2.296391446977)); +#22336 = CARTESIAN_POINT('',(5.912003704429,-2.379157876749)); +#22337 = CARTESIAN_POINT('',(5.881627459102,-2.469274244117)); +#22338 = CARTESIAN_POINT('',(5.851385842114,-2.56605210685)); +#22339 = CARTESIAN_POINT('',(5.821287018298,-2.668739426612)); +#22340 = CARTESIAN_POINT('',(5.791335962059,-2.776600365486)); +#22341 = CARTESIAN_POINT('',(5.761538546312,-2.888897879974)); +#22342 = CARTESIAN_POINT('',(5.731904543795,-3.004883548487)); +#22343 = CARTESIAN_POINT('',(5.702430632234,-3.123855667384)); +#22344 = CARTESIAN_POINT('',(5.673017731818,-3.245818178478)); +#22345 = CARTESIAN_POINT('',(5.643677937254,-3.370234368681)); +#22346 = CARTESIAN_POINT('',(5.614399262889,-3.496684889031)); +#22347 = CARTESIAN_POINT('',(5.585176590597,-3.624718936562)); +#22348 = CARTESIAN_POINT('',(5.55600334049,-3.753894160209)); +#22349 = CARTESIAN_POINT('',(5.526873658186,-3.883765855297)); +#22350 = CARTESIAN_POINT('',(5.507479087262,-3.970515471562)); +#22351 = CARTESIAN_POINT('',(5.497787143782,-4.013858398388)); +#22352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22353 = PCURVE('',#22354,#22359); +#22354 = CYLINDRICAL_SURFACE('',#22355,2.); +#22355 = AXIS2_PLACEMENT_3D('',#22356,#22357,#22358); +#22356 = CARTESIAN_POINT('',(-86.07536006148,5.659920093693E-12, + 78.95266725573)); +#22357 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22358 = DIRECTION('',(-0.906307787037,3.461640753466E-14,0.422618261741 + )); +#22359 = DEFINITIONAL_REPRESENTATION('',(#22360),#22386); +#22360 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22361,#22362,#22363,#22364, + #22365,#22366,#22367,#22368,#22369,#22370,#22371,#22372,#22373, + #22374,#22375,#22376,#22377,#22378,#22379,#22380,#22381,#22382, + #22383,#22384,#22385),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,2.589868701229E-02,5.179737402458E-02, + 7.769606103687E-02,0.103594748049,0.129493435061,0.155392122074, + 0.181290809086,0.207189496098,0.233088183111,0.258986870123, + 0.284885557135,0.310784244147,0.33668293116,0.362581618172, + 0.388480305184,0.414378992197,0.440277679209,0.466176366221, + 0.492075053234,0.517973740246,0.543872427258,0.56977111427), + .QUASI_UNIFORM_KNOTS.); +#22361 = CARTESIAN_POINT('',(5.497787143782,26.300000000039)); +#22362 = CARTESIAN_POINT('',(5.523684899831,26.230936834673)); +#22363 = CARTESIAN_POINT('',(5.575330704512,26.089492906072)); +#22364 = CARTESIAN_POINT('',(5.652468171128,25.867308254319)); +#22365 = CARTESIAN_POINT('',(5.729398952554,25.635027667386)); +#22366 = CARTESIAN_POINT('',(5.806224247212,25.392613207735)); +#22367 = CARTESIAN_POINT('',(5.883083712343,25.13988119375)); +#22368 = CARTESIAN_POINT('',(5.959963264186,24.877191681341)); +#22369 = CARTESIAN_POINT('',(6.037428077087,24.602875520384)); +#22370 = CARTESIAN_POINT('',(6.113181563395,24.325333441187)); +#22371 = CARTESIAN_POINT('',(6.187351753618,24.045380157866)); +#22372 = CARTESIAN_POINT('',(6.260163175538,23.763243140089)); +#22373 = CARTESIAN_POINT('',(6.331762831224,23.479306596419)); +#22374 = CARTESIAN_POINT('',(6.402265911053,23.19391502428)); +#22375 = CARTESIAN_POINT('',(6.47174834235,22.907415026765)); +#22376 = CARTESIAN_POINT('',(6.54024300091,22.62018449543)); +#22377 = CARTESIAN_POINT('',(6.607782985855,22.332474062308)); +#22378 = CARTESIAN_POINT('',(6.674750507145,22.043603195068)); +#22379 = CARTESIAN_POINT('',(6.741194617605,21.753946544073)); +#22380 = CARTESIAN_POINT('',(6.807221724418,21.463646224098)); +#22381 = CARTESIAN_POINT('',(6.872908274263,21.172906668442)); +#22382 = CARTESIAN_POINT('',(6.938325904569,20.881915571885)); +#22383 = CARTESIAN_POINT('',(7.003537397802,20.59086526477)); +#22384 = CARTESIAN_POINT('',(7.046911678358,20.396919270725)); +#22385 = CARTESIAN_POINT('',(7.068583470577,20.300000000037)); +#22386 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22387 = ADVANCED_FACE('',(#22388),#21960,.T.); +#22388 = FACE_BOUND('',#22389,.T.); +#22389 = EDGE_LOOP('',(#22390,#22391,#22419,#22493,#22516,#22590)); +#22390 = ORIENTED_EDGE('',*,*,#21944,.T.); +#22391 = ORIENTED_EDGE('',*,*,#22392,.T.); +#22392 = EDGE_CURVE('',#21922,#22393,#22395,.T.); +#22393 = VERTEX_POINT('',#22394); +#22394 = CARTESIAN_POINT('',(-83.25628219912,-26.30000000004, + 79.978727685707)); +#22395 = SURFACE_CURVE('',#22396,(#22401,#22408),.PCURVE_S1.); +#22396 = CIRCLE('',#22397,10.); +#22397 = AXIS2_PLACEMENT_3D('',#22398,#22399,#22400); +#22398 = CARTESIAN_POINT('',(-80.5201210525,-20.30000000004, + 72.461186719424)); +#22399 = DIRECTION('',(-0.939692620786,3.58771780773E-14,-0.342020143326 + )); +#22400 = DIRECTION('',(-0.241844762648,-0.707106781187,0.664463024389)); +#22401 = PCURVE('',#21960,#22402); +#22402 = DEFINITIONAL_REPRESENTATION('',(#22403),#22407); +#22403 = LINE('',#22404,#22405); +#22404 = CARTESIAN_POINT('',(6.28318530718,7.013858398379)); +#22405 = VECTOR('',#22406,1.); +#22406 = DIRECTION('',(-1.,3.042024380376E-12)); +#22407 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22408 = PCURVE('',#21554,#22409); +#22409 = DEFINITIONAL_REPRESENTATION('',(#22410),#22418); +#22410 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#22411,#22412,#22413,#22414 + ,#22415,#22416,#22417),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#22411 = CARTESIAN_POINT('',(2.928932188135,-27.37106781191)); +#22412 = CARTESIAN_POINT('',(-9.318516525782,-15.12361909799)); +#22413 = CARTESIAN_POINT('',(7.411809548973,-10.64074173715)); +#22414 = CARTESIAN_POINT('',(24.142135623729,-6.157864376313)); +#22415 = CARTESIAN_POINT('',(19.659258262891,-22.88819045107)); +#22416 = CARTESIAN_POINT('',(15.176380902053,-39.61851652582)); +#22417 = CARTESIAN_POINT('',(2.928932188135,-27.37106781191)); +#22418 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22419 = ORIENTED_EDGE('',*,*,#22420,.T.); +#22420 = EDGE_CURVE('',#22393,#22421,#22423,.T.); +#22421 = VERTEX_POINT('',#22422); +#22422 = CARTESIAN_POINT('',(-85.81970772734,-20.30000000004, + 81.174072640627)); +#22423 = SURFACE_CURVE('',#22424,(#22435,#22464),.PCURVE_S1.); +#22424 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22425,#22426,#22427,#22428, + #22429,#22430,#22431,#22432,#22433,#22434),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(0.,0.172651483079,0.369660405484,0.568571006082, + 0.569771114283),.UNSPECIFIED.); +#22425 = CARTESIAN_POINT('',(-83.25628219912,-26.30000000004, + 79.978727685707)); +#22426 = CARTESIAN_POINT('',(-83.37438276909,-25.83959604516, + 80.303206334941)); +#22427 = CARTESIAN_POINT('',(-83.57418327147,-25.30548010447, + 80.590692616289)); +#22428 = CARTESIAN_POINT('',(-84.1325594034,-23.99680251731, + 81.068733101663)); +#22429 = CARTESIAN_POINT('',(-84.47617672162,-23.27063012258, + 81.213827770463)); +#22430 = CARTESIAN_POINT('',(-85.15768066334,-21.8053797088, + 81.324424518639)); +#22431 = CARTESIAN_POINT('',(-85.50086731697,-21.05788263569, + 81.289044014093)); +#22432 = CARTESIAN_POINT('',(-85.8159317974,-20.30898264157, + 81.17544374675)); +#22433 = CARTESIAN_POINT('',(-85.81782027999,-20.30449132038, + 81.174759615282)); +#22434 = CARTESIAN_POINT('',(-85.81970772734,-20.30000000004, + 81.174072640627)); +#22435 = PCURVE('',#21960,#22436); +#22436 = DEFINITIONAL_REPRESENTATION('',(#22437),#22463); +#22437 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22438,#22439,#22440,#22441, + #22442,#22443,#22444,#22445,#22446,#22447,#22448,#22449,#22450, + #22451,#22452,#22453,#22454,#22455,#22456,#22457,#22458,#22459, + #22460,#22461,#22462),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,2.589868701286E-02,5.179737402573E-02, + 7.769606103859E-02,0.103594748051,0.129493435064,0.155392122077, + 0.18129080909,0.207189496103,0.233088183116,0.258986870129, + 0.284885557142,0.310784244154,0.336682931167,0.36258161818, + 0.388480305193,0.414378992206,0.440277679219,0.466176366232, + 0.492075053244,0.517973740257,0.54387242727,0.569771114283), + .QUASI_UNIFORM_KNOTS.); +#22438 = CARTESIAN_POINT('',(-0.141897054604,7.013858398384)); +#22439 = CARTESIAN_POINT('',(-0.150530209531,7.013858398384)); +#22440 = CARTESIAN_POINT('',(-0.168042545002,7.009833872295)); +#22441 = CARTESIAN_POINT('',(-0.195036896348,6.991929968915)); +#22442 = CARTESIAN_POINT('',(-0.222744846232,6.962361700317)); +#22443 = CARTESIAN_POINT('',(-0.251154218173,6.921344817999)); +#22444 = CARTESIAN_POINT('',(-0.28027192802,6.869046778578)); +#22445 = CARTESIAN_POINT('',(-0.310048628738,6.805815215719)); +#22446 = CARTESIAN_POINT('',(-0.340661836894,6.731325349782)); +#22447 = CARTESIAN_POINT('',(-0.371181602755,6.648558920008)); +#22448 = CARTESIAN_POINT('',(-0.401557848083,6.558442552638)); +#22449 = CARTESIAN_POINT('',(-0.431799465072,6.461664689901)); +#22450 = CARTESIAN_POINT('',(-0.461898288888,6.358977370137)); +#22451 = CARTESIAN_POINT('',(-0.491849345128,6.251116431261)); +#22452 = CARTESIAN_POINT('',(-0.521646760875,6.13881891677)); +#22453 = CARTESIAN_POINT('',(-0.551280763393,6.022833248255)); +#22454 = CARTESIAN_POINT('',(-0.580754674955,5.903861129353)); +#22455 = CARTESIAN_POINT('',(-0.610167575379,5.781898618237)); +#22456 = CARTESIAN_POINT('',(-0.639507369954,5.65748242801)); +#22457 = CARTESIAN_POINT('',(-0.668786044328,5.531031907638)); +#22458 = CARTESIAN_POINT('',(-0.698008716625,5.402997860096)); +#22459 = CARTESIAN_POINT('',(-0.72718196673,5.273822636457)); +#22460 = CARTESIAN_POINT('',(-0.756311649022,5.143950941401)); +#22461 = CARTESIAN_POINT('',(-0.775706219929,5.057201325183)); +#22462 = CARTESIAN_POINT('',(-0.785398163398,5.013858398388)); +#22463 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22464 = PCURVE('',#22222,#22465); +#22465 = DEFINITIONAL_REPRESENTATION('',(#22466),#22492); +#22466 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22467,#22468,#22469,#22470, + #22471,#22472,#22473,#22474,#22475,#22476,#22477,#22478,#22479, + #22480,#22481,#22482,#22483,#22484,#22485,#22486,#22487,#22488, + #22489,#22490,#22491),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,2.589868701286E-02,5.179737402573E-02, + 7.769606103859E-02,0.103594748051,0.129493435064,0.155392122077, + 0.18129080909,0.207189496103,0.233088183116,0.258986870129, + 0.284885557142,0.310784244154,0.336682931167,0.36258161818, + 0.388480305193,0.414378992206,0.440277679219,0.466176366232, + 0.492075053244,0.517973740257,0.54387242727,0.569771114283), + .QUASI_UNIFORM_KNOTS.); +#22467 = CARTESIAN_POINT('',(0.785398163397,-26.30000000004)); +#22468 = CARTESIAN_POINT('',(0.759500407348,-26.23093683467)); +#22469 = CARTESIAN_POINT('',(0.707854602666,-26.08949290607)); +#22470 = CARTESIAN_POINT('',(0.630717136048,-25.86730825431)); +#22471 = CARTESIAN_POINT('',(0.55378635462,-25.63502766737)); +#22472 = CARTESIAN_POINT('',(0.476961059961,-25.39261320772)); +#22473 = CARTESIAN_POINT('',(0.400101594828,-25.13988119373)); +#22474 = CARTESIAN_POINT('',(0.323222042984,-24.87719168131)); +#22475 = CARTESIAN_POINT('',(0.245757230081,-24.60287552035)); +#22476 = CARTESIAN_POINT('',(0.170003743773,-24.32533344115)); +#22477 = CARTESIAN_POINT('',(9.58335535487E-02,-24.04538015782)); +#22478 = CARTESIAN_POINT('',(2.30221316276E-02,-23.76324314004)); +#22479 = CARTESIAN_POINT('',(-4.857752405965E-02,-23.47930659636)); +#22480 = CARTESIAN_POINT('',(-0.11908060389,-23.19391502422)); +#22481 = CARTESIAN_POINT('',(-0.188563035188,-22.9074150267)); +#22482 = CARTESIAN_POINT('',(-0.257057693749,-22.62018449536)); +#22483 = CARTESIAN_POINT('',(-0.324597678695,-22.33247406222)); +#22484 = CARTESIAN_POINT('',(-0.391565199995,-22.0436031949)); +#22485 = CARTESIAN_POINT('',(-0.458009310467,-21.7539465438)); +#22486 = CARTESIAN_POINT('',(-0.52403641729,-21.46364622373)); +#22487 = CARTESIAN_POINT('',(-0.589722967142,-21.17290666802)); +#22488 = CARTESIAN_POINT('',(-0.655140597444,-20.88191557148)); +#22489 = CARTESIAN_POINT('',(-0.720352090661,-20.59086526449)); +#22490 = CARTESIAN_POINT('',(-0.763726371194,-20.39691927062)); +#22491 = CARTESIAN_POINT('',(-0.785398163397,-20.30000000004)); +#22492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22493 = ORIENTED_EDGE('',*,*,#22494,.T.); +#22494 = EDGE_CURVE('',#22421,#22495,#22497,.T.); +#22495 = VERTEX_POINT('',#22496); +#22496 = CARTESIAN_POINT('',(-86.75940034813,-20.30000000004, + 80.832052497301)); +#22497 = SURFACE_CURVE('',#22498,(#22502,#22509),.PCURVE_S1.); +#22498 = LINE('',#22499,#22500); +#22499 = CARTESIAN_POINT('',(-90.53119346597,-20.30000000004, + 79.459232072596)); +#22500 = VECTOR('',#22501,1.); +#22501 = DIRECTION('',(-0.939692620786,-7.103489272969E-13, + -0.342020143326)); +#22502 = PCURVE('',#21960,#22503); +#22503 = DEFINITIONAL_REPRESENTATION('',(#22504),#22508); +#22504 = LINE('',#22505,#22506); +#22505 = CARTESIAN_POINT('',(-0.785398163398,-1.15463194561E-14)); +#22506 = VECTOR('',#22507,1.); +#22507 = DIRECTION('',(0.,-1.)); +#22508 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22509 = PCURVE('',#22165,#22510); +#22510 = DEFINITIONAL_REPRESENTATION('',(#22511),#22515); +#22511 = LINE('',#22512,#22513); +#22512 = CARTESIAN_POINT('',(-2.013858398388,-20.30000000005)); +#22513 = VECTOR('',#22514,1.); +#22514 = DIRECTION('',(-1.,-7.462404678792E-13)); +#22515 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22516 = ORIENTED_EDGE('',*,*,#22517,.T.); +#22517 = EDGE_CURVE('',#22495,#22518,#22520,.T.); +#22518 = VERTEX_POINT('',#22519); +#22519 = CARTESIAN_POINT('',(-87.95474530305,-26.30000000004, + 78.268626969078)); +#22520 = SURFACE_CURVE('',#22521,(#22532,#22561),.PCURVE_S1.); +#22521 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22522,#22523,#22524,#22525, + #22526,#22527,#22528,#22529,#22530,#22531),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.475998478613E-03,0.,0.244637728195,0.486936605519, + 0.69927856449),.UNSPECIFIED.); +#22522 = CARTESIAN_POINT('',(-86.75940034813,-20.30000000004, + 80.832052497301)); +#22523 = CARTESIAN_POINT('',(-86.76128779548,-20.30449132038, + 80.831365522646)); +#22524 = CARTESIAN_POINT('',(-86.7631742083,-20.30898264157, + 80.830675704546)); +#22525 = CARTESIAN_POINT('',(-87.07754844717,-21.05788263615, + 80.715179013771)); +#22526 = CARTESIAN_POINT('',(-87.36318682599,-21.80537970882, + 80.521685923941)); +#22527 = CARTESIAN_POINT('',(-87.8141589141,-23.27063012259, + 79.998901609887)); +#22528 = CARTESIAN_POINT('',(-87.98411999595,-23.99680251732, + 79.666879690503)); +#22529 = CARTESIAN_POINT('',(-88.10458242805,-25.30548010447, + 78.941762173948)); +#22530 = CARTESIAN_POINT('',(-88.07284587302,-25.83959604516, + 78.593105618312)); +#22531 = CARTESIAN_POINT('',(-87.95474530305,-26.30000000004, + 78.268626969078)); +#22532 = PCURVE('',#21960,#22533); +#22533 = DEFINITIONAL_REPRESENTATION('',(#22534),#22560); +#22534 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22535,#22536,#22537,#22538, + #22539,#22540,#22541,#22542,#22543,#22544,#22545,#22546,#22547, + #22548,#22549,#22550,#22551,#22552,#22553,#22554,#22555,#22556, + #22557,#22558,#22559),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.475998478613E-03,3.037648165634E-02, + 6.222896179129E-02,9.408144192624E-02,0.125933922061,0.157786402196, + 0.189638882331,0.221491362466,0.253343842601,0.285196322736, + 0.317048802871,0.348901283006,0.380753763141,0.412606243276, + 0.444458723411,0.476311203546,0.508163683681,0.540016163816, + 0.571868643951,0.603721124085,0.63557360422,0.667426084355, + 0.69927856449),.UNSPECIFIED.); +#22535 = CARTESIAN_POINT('',(-0.785398163398,4.013858398388)); +#22536 = CARTESIAN_POINT('',(-0.775706219923,3.970515471577)); +#22537 = CARTESIAN_POINT('',(-0.756311649007,3.883765855334)); +#22538 = CARTESIAN_POINT('',(-0.727181966708,3.75389416026)); +#22539 = CARTESIAN_POINT('',(-0.698008716602,3.624718936616)); +#22540 = CARTESIAN_POINT('',(-0.668786044308,3.49668488908)); +#22541 = CARTESIAN_POINT('',(-0.639507369939,3.370234368719)); +#22542 = CARTESIAN_POINT('',(-0.61016757537,3.245818178506)); +#22543 = CARTESIAN_POINT('',(-0.580754674951,3.123855667401)); +#22544 = CARTESIAN_POINT('',(-0.551280763389,3.004883548502)); +#22545 = CARTESIAN_POINT('',(-0.521646760872,2.888897879988)); +#22546 = CARTESIAN_POINT('',(-0.491849345124,2.776600365498)); +#22547 = CARTESIAN_POINT('',(-0.461898288885,2.668739426622)); +#22548 = CARTESIAN_POINT('',(-0.431799465069,2.566052106859)); +#22549 = CARTESIAN_POINT('',(-0.40155784808,2.469274244124)); +#22550 = CARTESIAN_POINT('',(-0.371181602753,2.379157876755)); +#22551 = CARTESIAN_POINT('',(-0.340661836891,2.296391446982)); +#22552 = CARTESIAN_POINT('',(-0.310048628736,2.221901581046)); +#22553 = CARTESIAN_POINT('',(-0.280271928019,2.158670018188)); +#22554 = CARTESIAN_POINT('',(-0.251154218172,2.106371978768)); +#22555 = CARTESIAN_POINT('',(-0.222744846231,2.06535509645)); +#22556 = CARTESIAN_POINT('',(-0.195036896347,2.035786827853)); +#22557 = CARTESIAN_POINT('',(-0.168042545002,2.017882924473)); +#22558 = CARTESIAN_POINT('',(-0.150530209531,2.013858398384)); +#22559 = CARTESIAN_POINT('',(-0.141897054604,2.013858398384)); +#22560 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22561 = PCURVE('',#22354,#22562); +#22562 = DEFINITIONAL_REPRESENTATION('',(#22563),#22589); +#22563 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22564,#22565,#22566,#22567, + #22568,#22569,#22570,#22571,#22572,#22573,#22574,#22575,#22576, + #22577,#22578,#22579,#22580,#22581,#22582,#22583,#22584,#22585, + #22586,#22587,#22588),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.475998478613E-03,3.037648165634E-02, + 6.222896179129E-02,9.408144192624E-02,0.125933922061,0.157786402196, + 0.189638882331,0.221491362466,0.253343842601,0.285196322736, + 0.317048802871,0.348901283006,0.380753763141,0.412606243276, + 0.444458723411,0.476311203546,0.508163683681,0.540016163816, + 0.571868643951,0.603721124085,0.63557360422,0.667426084355, + 0.69927856449),.UNSPECIFIED.); +#22564 = CARTESIAN_POINT('',(7.068583470577,-20.30000000004)); +#22565 = CARTESIAN_POINT('',(7.046911678366,-20.39691927068)); +#22566 = CARTESIAN_POINT('',(7.00353739782,-20.59086526465)); +#22567 = CARTESIAN_POINT('',(6.938325904594,-20.8819155717)); +#22568 = CARTESIAN_POINT('',(6.872908274291,-21.17290666825)); +#22569 = CARTESIAN_POINT('',(6.807221724442,-21.46364622393)); +#22570 = CARTESIAN_POINT('',(6.741194617625,-21.75394654395)); +#22571 = CARTESIAN_POINT('',(6.674750507159,-22.04360319499)); +#22572 = CARTESIAN_POINT('',(6.607782985864,-22.33247406227)); +#22573 = CARTESIAN_POINT('',(6.540243000919,-22.6201844954)); +#22574 = CARTESIAN_POINT('',(6.471748342359,-22.90741502674)); +#22575 = CARTESIAN_POINT('',(6.402265911061,-23.19391502425)); +#22576 = CARTESIAN_POINT('',(6.331762831231,-23.4793065964)); +#22577 = CARTESIAN_POINT('',(6.260163175545,-23.76324314007)); +#22578 = CARTESIAN_POINT('',(6.187351753624,-24.04538015785)); +#22579 = CARTESIAN_POINT('',(6.113181563401,-24.32533344117)); +#22580 = CARTESIAN_POINT('',(6.037428077093,-24.60287552037)); +#22581 = CARTESIAN_POINT('',(5.959963264191,-24.87719168133)); +#22582 = CARTESIAN_POINT('',(5.883083712347,-25.13988119374)); +#22583 = CARTESIAN_POINT('',(5.806224247216,-25.39261320773)); +#22584 = CARTESIAN_POINT('',(5.729398952557,-25.63502766738)); +#22585 = CARTESIAN_POINT('',(5.65246817113,-25.86730825432)); +#22586 = CARTESIAN_POINT('',(5.575330704513,-26.08949290608)); +#22587 = CARTESIAN_POINT('',(5.523684899831,-26.23093683468)); +#22588 = CARTESIAN_POINT('',(5.497787143782,-26.30000000005)); +#22589 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22590 = ORIENTED_EDGE('',*,*,#22591,.T.); +#22591 = EDGE_CURVE('',#22518,#21945,#22592,.T.); +#22592 = SURFACE_CURVE('',#22593,(#22598,#22605),.PCURVE_S1.); +#22593 = CIRCLE('',#22594,10.); +#22594 = AXIS2_PLACEMENT_3D('',#22595,#22596,#22597); +#22595 = CARTESIAN_POINT('',(-85.21858415643,-20.30000000004, + 70.751086002797)); +#22596 = DIRECTION('',(0.939692620786,-3.58867320866E-14,0.342020143326) + ); +#22597 = DIRECTION('',(-0.241844762648,-0.707106781187,0.664463024389)); +#22598 = PCURVE('',#21960,#22599); +#22599 = DEFINITIONAL_REPRESENTATION('',(#22600),#22604); +#22600 = LINE('',#22601,#22602); +#22601 = CARTESIAN_POINT('',(-6.28318530718,2.013858398418)); +#22602 = VECTOR('',#22603,1.); +#22603 = DIRECTION('',(1.,-2.888773781868E-12)); +#22604 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22605 = PCURVE('',#21694,#22606); +#22606 = DEFINITIONAL_REPRESENTATION('',(#22607),#22615); +#22607 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#22608,#22609,#22610,#22611 + ,#22612,#22613,#22614),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#22608 = CARTESIAN_POINT('',(36.071067811864,-27.37106781191)); +#22609 = CARTESIAN_POINT('',(23.823619097947,-39.61851652583)); +#22610 = CARTESIAN_POINT('',(19.340741737109,-22.88819045107)); +#22611 = CARTESIAN_POINT('',(14.857864376271,-6.157864376317)); +#22612 = CARTESIAN_POINT('',(31.588190451026,-10.64074173716)); +#22613 = CARTESIAN_POINT('',(48.318516525782,-15.123619098)); +#22614 = CARTESIAN_POINT('',(36.071067811864,-27.37106781191)); +#22615 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22616 = ADVANCED_FACE('',(#22617),#22222,.T.); +#22617 = FACE_BOUND('',#22618,.T.); +#22618 = EDGE_LOOP('',(#22619,#22640,#22641,#22662)); +#22619 = ORIENTED_EDGE('',*,*,#22620,.T.); +#22620 = EDGE_CURVE('',#22150,#22421,#22621,.T.); +#22621 = SURFACE_CURVE('',#22622,(#22626,#22633),.PCURVE_S1.); +#22622 = LINE('',#22623,#22624); +#22623 = CARTESIAN_POINT('',(-85.81970772734,5.650155457978E-12, + 81.174072640627)); +#22624 = VECTOR('',#22625,1.); +#22625 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#22626 = PCURVE('',#22222,#22627); +#22627 = DEFINITIONAL_REPRESENTATION('',(#22628),#22632); +#22628 = LINE('',#22629,#22630); +#22629 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#22630 = VECTOR('',#22631,1.); +#22631 = DIRECTION('',(0.,-1.)); +#22632 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22633 = PCURVE('',#22165,#22634); +#22634 = DEFINITIONAL_REPRESENTATION('',(#22635),#22639); +#22635 = LINE('',#22636,#22637); +#22636 = CARTESIAN_POINT('',(3.,1.096207821126E-100)); +#22637 = VECTOR('',#22638,1.); +#22638 = DIRECTION('',(-7.308052140837E-101,-1.)); +#22639 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22640 = ORIENTED_EDGE('',*,*,#22420,.F.); +#22641 = ORIENTED_EDGE('',*,*,#22642,.T.); +#22642 = EDGE_CURVE('',#22393,#22178,#22643,.T.); +#22643 = SURFACE_CURVE('',#22644,(#22648,#22655),.PCURVE_S1.); +#22644 = LINE('',#22645,#22646); +#22645 = CARTESIAN_POINT('',(-83.25628219912,5.552245471946E-12, + 79.978727685707)); +#22646 = VECTOR('',#22647,1.); +#22647 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22648 = PCURVE('',#22222,#22649); +#22649 = DEFINITIONAL_REPRESENTATION('',(#22650),#22654); +#22650 = LINE('',#22651,#22652); +#22651 = CARTESIAN_POINT('',(0.785398163397,0.)); +#22652 = VECTOR('',#22653,1.); +#22653 = DIRECTION('',(0.,1.)); +#22654 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22655 = PCURVE('',#21554,#22656); +#22656 = DEFINITIONAL_REPRESENTATION('',(#22657),#22661); +#22657 = LINE('',#22658,#22659); +#22658 = CARTESIAN_POINT('',(2.,2.65991344973E-101)); +#22659 = VECTOR('',#22660,1.); +#22660 = DIRECTION('',(2.65991344973E-101,1.)); +#22661 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22662 = ORIENTED_EDGE('',*,*,#22177,.F.); +#22663 = ADVANCED_FACE('',(#22664),#22354,.T.); +#22664 = FACE_BOUND('',#22665,.T.); +#22665 = EDGE_LOOP('',(#22666,#22687,#22688,#22709)); +#22666 = ORIENTED_EDGE('',*,*,#22667,.T.); +#22667 = EDGE_CURVE('',#22284,#22518,#22668,.T.); +#22668 = SURFACE_CURVE('',#22669,(#22673,#22680),.PCURVE_S1.); +#22669 = LINE('',#22670,#22671); +#22670 = CARTESIAN_POINT('',(-87.95474530305,5.731703174857E-12, + 78.268626969078)); +#22671 = VECTOR('',#22672,1.); +#22672 = DIRECTION('',(-3.819497970755E-14,-1.,1.734343817174E-57)); +#22673 = PCURVE('',#22354,#22674); +#22674 = DEFINITIONAL_REPRESENTATION('',(#22675),#22679); +#22675 = LINE('',#22676,#22677); +#22676 = CARTESIAN_POINT('',(5.497787143782,0.)); +#22677 = VECTOR('',#22678,1.); +#22678 = DIRECTION('',(0.,-1.)); +#22679 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22680 = PCURVE('',#21694,#22681); +#22681 = DEFINITIONAL_REPRESENTATION('',(#22682),#22686); +#22682 = LINE('',#22683,#22684); +#22683 = CARTESIAN_POINT('',(37.,-4.920839882001E-100)); +#22684 = VECTOR('',#22685,1.); +#22685 = DIRECTION('',(2.65991344973E-101,-1.)); +#22686 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22687 = ORIENTED_EDGE('',*,*,#22517,.F.); +#22688 = ORIENTED_EDGE('',*,*,#22689,.T.); +#22689 = EDGE_CURVE('',#22495,#22148,#22690,.T.); +#22690 = SURFACE_CURVE('',#22691,(#22695,#22702),.PCURVE_S1.); +#22691 = LINE('',#22692,#22693); +#22692 = CARTESIAN_POINT('',(-86.75940034813,5.686046998561E-12, + 80.832052497301)); +#22693 = VECTOR('',#22694,1.); +#22694 = DIRECTION('',(3.819497970755E-14,1.,-1.734343817174E-57)); +#22695 = PCURVE('',#22354,#22696); +#22696 = DEFINITIONAL_REPRESENTATION('',(#22697),#22701); +#22697 = LINE('',#22698,#22699); +#22698 = CARTESIAN_POINT('',(7.068583470577,0.)); +#22699 = VECTOR('',#22700,1.); +#22700 = DIRECTION('',(0.,1.)); +#22701 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22702 = PCURVE('',#22165,#22703); +#22703 = DEFINITIONAL_REPRESENTATION('',(#22704),#22708); +#22704 = LINE('',#22705,#22706); +#22705 = CARTESIAN_POINT('',(2.,7.308052140837E-101)); +#22706 = VECTOR('',#22707,1.); +#22707 = DIRECTION('',(7.308052140837E-101,1.)); +#22708 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22709 = ORIENTED_EDGE('',*,*,#22311,.F.); +#22710 = ADVANCED_FACE('',(#22711),#21554,.T.); +#22711 = FACE_BOUND('',#22712,.T.); +#22712 = EDGE_LOOP('',(#22713,#22714,#22715,#22716,#22717,#22718)); +#22713 = ORIENTED_EDGE('',*,*,#21540,.F.); +#22714 = ORIENTED_EDGE('',*,*,#21734,.T.); +#22715 = ORIENTED_EDGE('',*,*,#22256,.F.); +#22716 = ORIENTED_EDGE('',*,*,#22642,.F.); +#22717 = ORIENTED_EDGE('',*,*,#22392,.F.); +#22718 = ORIENTED_EDGE('',*,*,#21921,.T.); +#22719 = ADVANCED_FACE('',(#22720),#22165,.T.); +#22720 = FACE_BOUND('',#22721,.T.); +#22721 = EDGE_LOOP('',(#22722,#22723,#22724,#22725)); +#22722 = ORIENTED_EDGE('',*,*,#22494,.F.); +#22723 = ORIENTED_EDGE('',*,*,#22620,.F.); +#22724 = ORIENTED_EDGE('',*,*,#22147,.F.); +#22725 = ORIENTED_EDGE('',*,*,#22689,.F.); +#22726 = ADVANCED_FACE('',(#22727),#21694,.T.); +#22727 = FACE_BOUND('',#22728,.T.); +#22728 = EDGE_LOOP('',(#22729,#22730,#22731,#22732,#22733,#22734)); +#22729 = ORIENTED_EDGE('',*,*,#22073,.F.); +#22730 = ORIENTED_EDGE('',*,*,#21972,.T.); +#22731 = ORIENTED_EDGE('',*,*,#22591,.F.); +#22732 = ORIENTED_EDGE('',*,*,#22667,.F.); +#22733 = ORIENTED_EDGE('',*,*,#22283,.F.); +#22734 = ORIENTED_EDGE('',*,*,#21678,.T.); +#22735 = ADVANCED_FACE('',(#22736),#22751,.T.); +#22736 = FACE_BOUND('',#22737,.T.); +#22737 = EDGE_LOOP('',(#22738,#22778,#22837,#22914,#22943)); +#22738 = ORIENTED_EDGE('',*,*,#22739,.F.); +#22739 = EDGE_CURVE('',#22740,#22742,#22744,.T.); +#22740 = VERTEX_POINT('',#22741); +#22741 = CARTESIAN_POINT('',(-55.15603122477,17.09740748936,8.5)); +#22742 = VERTEX_POINT('',#22743); +#22743 = CARTESIAN_POINT('',(-53.,23.300000000026,8.5)); +#22744 = SURFACE_CURVE('',#22745,(#22750,#22762),.PCURVE_S1.); +#22745 = CIRCLE('',#22746,10.); +#22746 = AXIS2_PLACEMENT_3D('',#22747,#22748,#22749); +#22747 = CARTESIAN_POINT('',(-63.,23.300000000026,8.5)); +#22748 = DIRECTION('',(4.241071166072E-29,6.004677426212E-16,1.)); +#22749 = DIRECTION('',(0.886877334465,-0.462004971415,2.774190822653E-16 + )); +#22750 = PCURVE('',#22751,#22756); +#22751 = TOROIDAL_SURFACE('',#22752,10.,5.); +#22752 = AXIS2_PLACEMENT_3D('',#22753,#22754,#22755); +#22753 = CARTESIAN_POINT('',(-63.,23.300000000026,13.5)); +#22754 = DIRECTION('',(-4.240620349369E-29,-6.004677426212E-16,-1.)); +#22755 = DIRECTION('',(-1.,-3.830678817595E-14,6.540819411678E-29)); +#22756 = DEFINITIONAL_REPRESENTATION('',(#22757),#22761); +#22757 = LINE('',#22758,#22759); +#22758 = CARTESIAN_POINT('',(9.9050325404,1.570796326795)); +#22759 = VECTOR('',#22760,1.); +#22760 = DIRECTION('',(-1.,0.)); +#22761 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22762 = PCURVE('',#22763,#22768); +#22763 = PLANE('',#22764); +#22764 = AXIS2_PLACEMENT_3D('',#22765,#22766,#22767); +#22765 = CARTESIAN_POINT('',(-40.49999999997,16.900000000012,8.5)); +#22766 = DIRECTION('',(-4.240620349369E-29,-6.004677426212E-16,-1.)); +#22767 = DIRECTION('',(1.,3.819991382918E-14,-6.534401951903E-29)); +#22768 = DEFINITIONAL_REPRESENTATION('',(#22769),#22777); +#22769 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#22770,#22771,#22772,#22773 + ,#22774,#22775,#22776),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#22770 = CARTESIAN_POINT('',(-13.63122665537,-1.779950285864)); +#22771 = CARTESIAN_POINT('',(-5.629065816968,-17.14111631961)); +#22772 = CARTESIAN_POINT('',(-22.93330625314,-16.39060787396)); +#22773 = CARTESIAN_POINT('',(-40.23754668932,-15.64009942831)); +#22774 = CARTESIAN_POINT('',(-30.93546709154,-1.029441840217)); +#22775 = CARTESIAN_POINT('',(-21.63338749377,13.581215747883)); +#22776 = CARTESIAN_POINT('',(-13.63122665537,-1.779950285864)); +#22777 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22778 = ORIENTED_EDGE('',*,*,#22779,.F.); +#22779 = EDGE_CURVE('',#22780,#22740,#22782,.T.); +#22780 = VERTEX_POINT('',#22781); +#22781 = CARTESIAN_POINT('',(-58.11198325875,18.347352920869, + 9.531425563737)); +#22782 = SURFACE_CURVE('',#22783,(#22794,#22823),.PCURVE_S1.); +#22783 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22784,#22785,#22786,#22787, + #22788,#22789,#22790,#22791,#22792,#22793),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.072156503551,-1.04598248422,-0.946418753147, + -0.848256540402,-0.750094327657),.UNSPECIFIED.); +#22784 = CARTESIAN_POINT('',(-58.11198325874,18.347352920868, + 9.531425563735)); +#22785 = CARTESIAN_POINT('',(-58.04082429446,18.317262844542, + 9.476704545222)); +#22786 = CARTESIAN_POINT('',(-57.9679894482,18.286464109551, + 9.423620989079)); +#22787 = CARTESIAN_POINT('',(-57.61239793046,18.136099696335, + 9.178405891423)); +#22788 = CARTESIAN_POINT('',(-57.31270007605,18.009370317899, + 9.015206983341)); +#22789 = CARTESIAN_POINT('',(-56.74866248454,17.770862993492, + 8.771545663279)); +#22790 = CARTESIAN_POINT('',(-56.43221650652,17.637051551357, + 8.667639114369)); +#22791 = CARTESIAN_POINT('',(-55.78659338139,17.364045201302, + 8.531827136925)); +#22792 = CARTESIAN_POINT('',(-55.45740226526,17.224844386479,8.5)); +#22793 = CARTESIAN_POINT('',(-55.15603122477,17.09740748936,8.5)); +#22794 = PCURVE('',#22751,#22795); +#22795 = DEFINITIONAL_REPRESENTATION('',(#22796),#22822); +#22796 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22797,#22798,#22799,#22800, + #22801,#22802,#22803,#22804,#22805,#22806,#22807,#22808,#22809, + #22810,#22811,#22812,#22813,#22814,#22815,#22816,#22817,#22818, + #22819,#22820,#22821),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.072156503551,-1.057517313737, + -1.042878123924,-1.028238934111,-1.013599744297,-0.998960554484, + -0.984321364671,-0.969682174857,-0.955042985044,-0.94040379523, + -0.925764605417,-0.911125415604,-0.89648622579,-0.881847035977, + -0.867207846164,-0.85256865635,-0.837929466537,-0.823290276724, + -0.80865108691,-0.794011897097,-0.779372707283,-0.76473351747, + -0.750094327657),.QUASI_UNIFORM_KNOTS.); +#22797 = CARTESIAN_POINT('',(3.933558403265,2.22470066041)); +#22798 = CARTESIAN_POINT('',(3.93118590762,2.214637667881)); +#22799 = CARTESIAN_POINT('',(3.926462207315,2.194451152099)); +#22800 = CARTESIAN_POINT('',(3.919469593508,2.164092387505)); +#22801 = CARTESIAN_POINT('',(3.912597553947,2.133759016752)); +#22802 = CARTESIAN_POINT('',(3.905878717575,2.10354918231)); +#22803 = CARTESIAN_POINT('',(3.899342966442,2.07356946875)); +#22804 = CARTESIAN_POINT('',(3.893014047333,2.043923623504)); +#22805 = CARTESIAN_POINT('',(3.886916637252,2.014743162347)); +#22806 = CARTESIAN_POINT('',(3.881054375958,1.986069391598)); +#22807 = CARTESIAN_POINT('',(3.875493566743,1.958288024377)); +#22808 = CARTESIAN_POINT('',(3.869899851068,1.929725670733)); +#22809 = CARTESIAN_POINT('',(3.864321874099,1.900548130827)); +#22810 = CARTESIAN_POINT('',(3.858787690681,1.870857537053)); +#22811 = CARTESIAN_POINT('',(3.853326125254,1.840773276687)); +#22812 = CARTESIAN_POINT('',(3.847961282768,1.810408918354)); +#22813 = CARTESIAN_POINT('',(3.842714451897,1.779876976094)); +#22814 = CARTESIAN_POINT('',(3.837603494759,1.749285777047)); +#22815 = CARTESIAN_POINT('',(3.832645935174,1.718740047584)); +#22816 = CARTESIAN_POINT('',(3.827857575485,1.68834975922)); +#22817 = CARTESIAN_POINT('',(3.82325155352,1.658229385268)); +#22818 = CARTESIAN_POINT('',(3.818838936851,1.628496510216)); +#22819 = CARTESIAN_POINT('',(3.814629107745,1.599270610968)); +#22820 = CARTESIAN_POINT('',(3.811962679272,1.580204749227)); +#22821 = CARTESIAN_POINT('',(3.81066582369,1.570796326795)); +#22822 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22823 = PCURVE('',#20680,#22824); +#22824 = DEFINITIONAL_REPRESENTATION('',(#22825),#22836); +#22825 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22826,#22827,#22828,#22829, + #22830,#22831,#22832,#22833,#22834,#22835),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.072156503551,-1.04598248422,-0.946418753147, + -0.848256540402,-0.750094327657),.UNSPECIFIED.); +#22826 = CARTESIAN_POINT('',(38.122109819926,5.031425563735)); +#22827 = CARTESIAN_POINT('',(38.044850445793,4.976704545222)); +#22828 = CARTESIAN_POINT('',(37.965771517455,4.923620989079)); +#22829 = CARTESIAN_POINT('',(37.57969537956,4.678405891423)); +#22830 = CARTESIAN_POINT('',(37.254304630929,4.515206983342)); +#22831 = CARTESIAN_POINT('',(36.641912478443,4.271545663279)); +#22832 = CARTESIAN_POINT('',(36.298337800896,4.167639114369)); +#22833 = CARTESIAN_POINT('',(35.597365842203,4.031827136925)); +#22834 = CARTESIAN_POINT('',(35.239953394476,4.)); +#22835 = CARTESIAN_POINT('',(34.91274601866,4.)); +#22836 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22837 = ORIENTED_EDGE('',*,*,#22838,.F.); +#22838 = EDGE_CURVE('',#22839,#22780,#22841,.T.); +#22839 = VERTEX_POINT('',#22840); +#22840 = CARTESIAN_POINT('',(-61.52966235425,18.521076773242,13.5)); +#22841 = SURFACE_CURVE('',#22842,(#22851,#22880),.PCURVE_S1.); +#22842 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22843,#22844,#22845,#22846, + #22847,#22848,#22849,#22850),.UNSPECIFIED.,.F.,.F.,(4,2,2,4),( + -1.80953289085,-1.808667487311,-1.536099373537,-1.399847384662), + .UNSPECIFIED.); +#22843 = CARTESIAN_POINT('',(-61.52966235425,18.521076773242,13.5)); +#22844 = CARTESIAN_POINT('',(-61.52782294596,18.521642706429, + 13.497278344907)); +#22845 = CARTESIAN_POINT('',(-61.52598320975,18.522207577994, + 13.494556688076)); +#22846 = CARTESIAN_POINT('',(-60.94459553198,18.700349278157, + 12.634621231189)); +#22847 = CARTESIAN_POINT('',(-60.18561776626,18.817629927139, + 11.553471842447)); +#22848 = CARTESIAN_POINT('',(-58.87876245473,18.620707024365, + 10.169713345628)); +#22849 = CARTESIAN_POINT('',(-58.47695607637,18.501684283749, + 9.812088506353)); +#22850 = CARTESIAN_POINT('',(-58.11198325875,18.347352920869, + 9.531425563737)); +#22851 = PCURVE('',#22751,#22852); +#22852 = DEFINITIONAL_REPRESENTATION('',(#22853),#22879); +#22853 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22854,#22855,#22856,#22857, + #22858,#22859,#22860,#22861,#22862,#22863,#22864,#22865,#22866, + #22867,#22868,#22869,#22870,#22871,#22872,#22873,#22874,#22875, + #22876,#22877,#22878),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.80953289085,-1.790910822387, + -1.772288753924,-1.753666685461,-1.735044616998,-1.716422548535, + -1.697800480071,-1.679178411608,-1.660556343145,-1.641934274682, + -1.623312206219,-1.604690137756,-1.586068069293,-1.56744600083, + -1.548823932367,-1.530201863904,-1.511579795441,-1.492957726977, + -1.474335658514,-1.455713590051,-1.437091521588,-1.418469453125, + -1.399847384662),.QUASI_UNIFORM_KNOTS.); +#22854 = CARTESIAN_POINT('',(4.413909216026,3.14159265359)); +#22855 = CARTESIAN_POINT('',(4.405640748954,3.129897490546)); +#22856 = CARTESIAN_POINT('',(4.388812133279,3.106090373129)); +#22857 = CARTESIAN_POINT('',(4.362838591884,3.069217741913)); +#22858 = CARTESIAN_POINT('',(4.3362733118,3.031274238917)); +#22859 = CARTESIAN_POINT('',(4.30927458852,2.992341622015)); +#22860 = CARTESIAN_POINT('',(4.282008861992,2.952493751811)); +#22861 = CARTESIAN_POINT('',(4.254649893873,2.911797001496)); +#22862 = CARTESIAN_POINT('',(4.22737455639,2.870311242251)); +#22863 = CARTESIAN_POINT('',(4.20035921405,2.828090957627)); +#22864 = CARTESIAN_POINT('',(4.173775755908,2.785186136649)); +#22865 = CARTESIAN_POINT('',(4.147788348686,2.741644125454)); +#22866 = CARTESIAN_POINT('',(4.122548859592,2.697507347189)); +#22867 = CARTESIAN_POINT('',(4.09819924356,2.652825372619)); +#22868 = CARTESIAN_POINT('',(4.074850688222,2.607611896539)); +#22869 = CARTESIAN_POINT('',(4.052652655944,2.562005462601)); +#22870 = CARTESIAN_POINT('',(4.031529737187,2.515667745309)); +#22871 = CARTESIAN_POINT('',(4.012400269735,2.470550947747)); +#22872 = CARTESIAN_POINT('',(3.995183969075,2.426718415631)); +#22873 = CARTESIAN_POINT('',(3.979743958969,2.38407903125)); +#22874 = CARTESIAN_POINT('',(3.965959520328,2.342589333701)); +#22875 = CARTESIAN_POINT('',(3.953709609304,2.302198454374)); +#22876 = CARTESIAN_POINT('',(3.942878504054,2.262861846437)); +#22877 = CARTESIAN_POINT('',(3.936531688948,2.237313097577)); +#22878 = CARTESIAN_POINT('',(3.933558403265,2.224700660411)); +#22879 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22880 = PCURVE('',#22881,#22886); +#22881 = CYLINDRICAL_SURFACE('',#22882,5.); +#22882 = AXIS2_PLACEMENT_3D('',#22883,#22884,#22885); +#22883 = CARTESIAN_POINT('',(-60.0593247085,13.742153546458,19.8)); +#22884 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#22885 = DIRECTION('',(5.076540218662E-02,0.998710605702, + -8.542425061624E-16)); +#22886 = DEFINITIONAL_REPRESENTATION('',(#22887),#22913); +#22887 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22888,#22889,#22890,#22891, + #22892,#22893,#22894,#22895,#22896,#22897,#22898,#22899,#22900, + #22901,#22902,#22903,#22904,#22905,#22906,#22907,#22908,#22909, + #22910,#22911,#22912),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.80953289085,-1.790910822387, + -1.772288753924,-1.753666685461,-1.735044616998,-1.716422548535, + -1.697800480071,-1.679178411608,-1.660556343145,-1.641934274682, + -1.623312206219,-1.604690137756,-1.586068069293,-1.56744600083, + -1.548823932367,-1.530201863904,-1.511579795441,-1.492957726977, + -1.474335658514,-1.455713590051,-1.437091521588,-1.418469453125, + -1.399847384662),.QUASI_UNIFORM_KNOTS.); +#22888 = CARTESIAN_POINT('',(0.349266996678,-6.3)); +#22889 = CARTESIAN_POINT('',(0.340997096147,-6.358472257591)); +#22890 = CARTESIAN_POINT('',(0.324171089878,-6.477514219139)); +#22891 = CARTESIAN_POINT('',(0.298098183854,-6.66164355055)); +#22892 = CARTESIAN_POINT('',(0.271216920264,-6.850616698887)); +#22893 = CARTESIAN_POINT('',(0.243549967989,-7.043699269531)); +#22894 = CARTESIAN_POINT('',(0.215116343472,-7.240160038992)); +#22895 = CARTESIAN_POINT('',(0.185931349838,-7.439266921725)); +#22896 = CARTESIAN_POINT('',(0.156006314845,-7.640288109264)); +#22897 = CARTESIAN_POINT('',(0.125348454062,-7.842491546889)); +#22898 = CARTESIAN_POINT('',(9.396051009336E-02,-8.045145887823)); +#22899 = CARTESIAN_POINT('',(6.184127385425E-02,-8.24751719976)); +#22900 = CARTESIAN_POINT('',(2.898295120307E-02,-8.448881184571)); +#22901 = CARTESIAN_POINT('',(-4.619542846188E-03,-8.648477592949)); +#22902 = CARTESIAN_POINT('',(-3.90036084494E-02,-8.845680346127)); +#22903 = CARTESIAN_POINT('',(-7.410834920645E-02,-9.039362634343)); +#22904 = CARTESIAN_POINT('',(-0.110261836153,-9.230266401288)); +#22905 = CARTESIAN_POINT('',(-0.145941007794,-9.410039544505)); +#22906 = CARTESIAN_POINT('',(-0.181062555183,-9.578649832301)); +#22907 = CARTESIAN_POINT('',(-0.215678230734,-9.736622421779)); +#22908 = CARTESIAN_POINT('',(-0.249799216097,-9.884333117899)); +#22909 = CARTESIAN_POINT('',(-0.283443025332,-10.02219774539)); +#22910 = CARTESIAN_POINT('',(-0.316621339719,-10.15062140204)); +#22911 = CARTESIAN_POINT('',(-0.33843500056,-10.23021518312)); +#22912 = CARTESIAN_POINT('',(-0.349266996678,-10.26857443626)); +#22913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22914 = ORIENTED_EDGE('',*,*,#22915,.F.); +#22915 = EDGE_CURVE('',#22916,#22839,#22918,.T.); +#22916 = VERTEX_POINT('',#22917); +#22917 = CARTESIAN_POINT('',(-58.,23.300000000026,13.5)); +#22918 = SURFACE_CURVE('',#22919,(#22924,#22931),.PCURVE_S1.); +#22919 = CIRCLE('',#22920,5.); +#22920 = AXIS2_PLACEMENT_3D('',#22921,#22922,#22923); +#22921 = CARTESIAN_POINT('',(-63.,23.300000000026,13.5)); +#22922 = DIRECTION('',(-4.241071166072E-29,-6.004677426212E-16,-1.)); +#22923 = DIRECTION('',(0.886877334465,-0.462004971415,2.774190822653E-16 + )); +#22924 = PCURVE('',#22751,#22925); +#22925 = DEFINITIONAL_REPRESENTATION('',(#22926),#22930); +#22926 = LINE('',#22927,#22928); +#22927 = CARTESIAN_POINT('',(-2.661338073959,3.14159265359)); +#22928 = VECTOR('',#22929,1.); +#22929 = DIRECTION('',(1.,-3.490398718065E-16)); +#22930 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22931 = PCURVE('',#22932,#22937); +#22932 = CYLINDRICAL_SURFACE('',#22933,5.); +#22933 = AXIS2_PLACEMENT_3D('',#22934,#22935,#22936); +#22934 = CARTESIAN_POINT('',(-63.,23.300000000026,19.8)); +#22935 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#22936 = DIRECTION('',(0.707106781187,-0.707106781187,6.048205210165E-16 + )); +#22937 = DEFINITIONAL_REPRESENTATION('',(#22938),#22942); +#22938 = LINE('',#22939,#22940); +#22939 = CARTESIAN_POINT('',(6.588328890946,-6.3)); +#22940 = VECTOR('',#22941,1.); +#22941 = DIRECTION('',(-1.,0.)); +#22942 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22943 = ORIENTED_EDGE('',*,*,#22944,.F.); +#22944 = EDGE_CURVE('',#22742,#22916,#22945,.T.); +#22945 = SURFACE_CURVE('',#22946,(#22951,#22958),.PCURVE_S1.); +#22946 = CIRCLE('',#22947,5.); +#22947 = AXIS2_PLACEMENT_3D('',#22948,#22949,#22950); +#22948 = CARTESIAN_POINT('',(-53.,23.300000000026,13.5)); +#22949 = DIRECTION('',(-2.221270227458E-14,1.,-8.225123475462E-16)); +#22950 = DIRECTION('',(-3.392411871932E-29,-8.225123475462E-16,-1.)); +#22951 = PCURVE('',#22751,#22952); +#22952 = DEFINITIONAL_REPRESENTATION('',(#22953),#22957); +#22953 = LINE('',#22954,#22955); +#22954 = CARTESIAN_POINT('',(3.14159265359,1.570796326795)); +#22955 = VECTOR('',#22956,1.); +#22956 = DIRECTION('',(2.827159716856E-16,1.)); +#22957 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22958 = PCURVE('',#22959,#22964); +#22959 = CYLINDRICAL_SURFACE('',#22960,5.); +#22960 = AXIS2_PLACEMENT_3D('',#22961,#22962,#22963); +#22961 = CARTESIAN_POINT('',(-53.,23.600000000018,13.5)); +#22962 = DIRECTION('',(2.228671714288E-14,-1.,6.004677426212E-16)); +#22963 = DIRECTION('',(-0.707106781187,-1.618368363481E-14, + -0.707106781187)); +#22964 = DEFINITIONAL_REPRESENTATION('',(#22965),#22969); +#22965 = LINE('',#22966,#22967); +#22966 = CARTESIAN_POINT('',(0.785398163397,0.299999999992)); +#22967 = VECTOR('',#22968,1.); +#22968 = DIRECTION('',(-1.,0.)); +#22969 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#22970 = ADVANCED_FACE('',(#22971),#22959,.T.); +#22971 = FACE_BOUND('',#22972,.T.); +#22972 = EDGE_LOOP('',(#22973,#23021,#23042,#23043)); +#22973 = ORIENTED_EDGE('',*,*,#22974,.T.); +#22974 = EDGE_CURVE('',#22975,#22977,#22979,.T.); +#22975 = VERTEX_POINT('',#22976); +#22976 = CARTESIAN_POINT('',(-58.,30.300000000024,13.5)); +#22977 = VERTEX_POINT('',#22978); +#22978 = CARTESIAN_POINT('',(-53.,28.185714285737,8.5)); +#22979 = SURFACE_CURVE('',#22980,(#22985,#23014),.PCURVE_S1.); +#22980 = ELLIPSE('',#22981,5.428646616021,5.); +#22981 = AXIS2_PLACEMENT_3D('',#22982,#22983,#22984); +#22982 = CARTESIAN_POINT('',(-53.,28.185714285737,13.5)); +#22983 = DIRECTION('',(-0.38946828995,-0.921039874882,5.530547345347E-16 + )); +#22984 = DIRECTION('',(-0.921039874882,0.38946828995,-3.594919050458E-16 + )); +#22985 = PCURVE('',#22959,#22986); +#22986 = DEFINITIONAL_REPRESENTATION('',(#22987),#23013); +#22987 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#22988,#22989,#22990,#22991, + #22992,#22993,#22994,#22995,#22996,#22997,#22998,#22999,#23000, + #23001,#23002,#23003,#23004,#23005,#23006,#23007,#23008,#23009, + #23010,#23011,#23012),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,7.139983303613E-02,0.142799666072, + 0.214199499108,0.285599332145,0.356999165181,0.428398998217, + 0.499798831253,0.571198664289,0.642598497325,0.713998330361, + 0.785398163397,0.856797996434,0.92819782947,0.999597662506, + 1.070997495542,1.142397328578,1.213797161614,1.28519699465, + 1.356596827687,1.427996660723,1.499396493759,1.570796326795), + .QUASI_UNIFORM_KNOTS.); +#22988 = CARTESIAN_POINT('',(-0.785398163397,-6.700000000006)); +#22989 = CARTESIAN_POINT('',(-0.761598219052,-6.700004559581)); +#22990 = CARTESIAN_POINT('',(-0.713998330361,-6.696403526109)); +#22991 = CARTESIAN_POINT('',(-0.642598497325,-6.680259073198)); +#22992 = CARTESIAN_POINT('',(-0.571198664289,-6.653437900998)); +#22993 = CARTESIAN_POINT('',(-0.499798831253,-6.616080994023)); +#22994 = CARTESIAN_POINT('',(-0.428398998217,-6.568377559655)); +#22995 = CARTESIAN_POINT('',(-0.356999165181,-6.510570993103)); +#22996 = CARTESIAN_POINT('',(-0.285599332145,-6.442955780465)); +#22997 = CARTESIAN_POINT('',(-0.214199499108,-6.365876495583)); +#22998 = CARTESIAN_POINT('',(-0.142799666072,-6.27972591087)); +#22999 = CARTESIAN_POINT('',(-7.139983303612E-02,-6.184943031555)); +#23000 = CARTESIAN_POINT('',(9.399938771704E-15,-6.082010849037)); +#23001 = CARTESIAN_POINT('',(7.139983303614E-02,-5.97145388224)); +#23002 = CARTESIAN_POINT('',(0.142799666072,-5.853835504085)); +#23003 = CARTESIAN_POINT('',(0.214199499108,-5.729755070912)); +#23004 = CARTESIAN_POINT('',(0.285599332145,-5.599844868024)); +#23005 = CARTESIAN_POINT('',(0.356999165181,-5.464766888559)); +#23006 = CARTESIAN_POINT('',(0.428398998217,-5.325209456995)); +#23007 = CARTESIAN_POINT('',(0.499798831253,-5.181883733265)); +#23008 = CARTESIAN_POINT('',(0.571198664289,-5.035520045335)); +#23009 = CARTESIAN_POINT('',(0.642598497325,-4.886864330039)); +#23010 = CARTESIAN_POINT('',(0.713998330361,-4.736673725778)); +#23011 = CARTESIAN_POINT('',(0.761598219052,-4.636034559664)); +#23012 = CARTESIAN_POINT('',(0.785398163397,-4.585714285719)); +#23013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23014 = PCURVE('',#20817,#23015); +#23015 = DEFINITIONAL_REPRESENTATION('',(#23016),#23020); +#23016 = ELLIPSE('',#23017,5.428646616021,5.); +#23017 = AXIS2_PLACEMENT_2D('',#23018,#23019); +#23018 = CARTESIAN_POINT('',(5.428646616021,9.)); +#23019 = DIRECTION('',(-1.,-7.894001734057E-17)); +#23020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23021 = ORIENTED_EDGE('',*,*,#23022,.F.); +#23022 = EDGE_CURVE('',#22742,#22977,#23023,.T.); +#23023 = SURFACE_CURVE('',#23024,(#23028,#23035),.PCURVE_S1.); +#23024 = LINE('',#23025,#23026); +#23025 = CARTESIAN_POINT('',(-53.,23.600000000018,8.5)); +#23026 = VECTOR('',#23027,1.); +#23027 = DIRECTION('',(-2.228671714288E-14,1.,-6.004677426212E-16)); +#23028 = PCURVE('',#22959,#23029); +#23029 = DEFINITIONAL_REPRESENTATION('',(#23030),#23034); +#23030 = LINE('',#23031,#23032); +#23031 = CARTESIAN_POINT('',(0.785398163397,-3.552713678801E-15)); +#23032 = VECTOR('',#23033,1.); +#23033 = DIRECTION('',(0.,-1.)); +#23034 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23035 = PCURVE('',#22763,#23036); +#23036 = DEFINITIONAL_REPRESENTATION('',(#23037),#23041); +#23037 = LINE('',#23038,#23039); +#23038 = CARTESIAN_POINT('',(-12.50000000002,-6.700000000006)); +#23039 = VECTOR('',#23040,1.); +#23040 = DIRECTION('',(1.59131966863E-14,-1.)); +#23041 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23042 = ORIENTED_EDGE('',*,*,#22944,.T.); +#23043 = ORIENTED_EDGE('',*,*,#23044,.F.); +#23044 = EDGE_CURVE('',#22975,#22916,#23045,.T.); +#23045 = SURFACE_CURVE('',#23046,(#23050,#23057),.PCURVE_S1.); +#23046 = LINE('',#23047,#23048); +#23047 = CARTESIAN_POINT('',(-58.,23.600000000018,13.5)); +#23048 = VECTOR('',#23049,1.); +#23049 = DIRECTION('',(2.228671714288E-14,-1.,6.004677426212E-16)); +#23050 = PCURVE('',#22959,#23051); +#23051 = DEFINITIONAL_REPRESENTATION('',(#23052),#23056); +#23052 = LINE('',#23053,#23054); +#23053 = CARTESIAN_POINT('',(-0.785398163397,-3.552713678801E-15)); +#23054 = VECTOR('',#23055,1.); +#23055 = DIRECTION('',(0.,1.)); +#23056 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23057 = PCURVE('',#23058,#23063); +#23058 = PLANE('',#23059); +#23059 = AXIS2_PLACEMENT_3D('',#23060,#23061,#23062); +#23060 = CARTESIAN_POINT('',(-58.,30.300000000024,19.8)); +#23061 = DIRECTION('',(1.,2.228671714288E-14,-5.173274019471E-29)); +#23062 = DIRECTION('',(2.228671714288E-14,-1.,8.553453836232E-16)); +#23063 = DEFINITIONAL_REPRESENTATION('',(#23064),#23068); +#23064 = LINE('',#23065,#23066); +#23065 = CARTESIAN_POINT('',(6.700000000006,6.3)); +#23066 = VECTOR('',#23067,1.); +#23067 = DIRECTION('',(1.,2.54877641002E-16)); +#23068 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23069 = ADVANCED_FACE('',(#23070),#22881,.T.); +#23070 = FACE_BOUND('',#23071,.T.); +#23071 = EDGE_LOOP('',(#23072,#23095,#23096,#23119)); +#23072 = ORIENTED_EDGE('',*,*,#23073,.F.); +#23073 = EDGE_CURVE('',#22839,#23074,#23076,.T.); +#23074 = VERTEX_POINT('',#23075); +#23075 = CARTESIAN_POINT('',(-61.52966235425,18.521076773242,4.5)); +#23076 = SURFACE_CURVE('',#23077,(#23081,#23088),.PCURVE_S1.); +#23077 = LINE('',#23078,#23079); +#23078 = CARTESIAN_POINT('',(-61.52966235425,18.521076773242,19.8)); +#23079 = VECTOR('',#23080,1.); +#23080 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23081 = PCURVE('',#22881,#23082); +#23082 = DEFINITIONAL_REPRESENTATION('',(#23083),#23087); +#23083 = LINE('',#23084,#23085); +#23084 = CARTESIAN_POINT('',(0.349266996678,0.)); +#23085 = VECTOR('',#23086,1.); +#23086 = DIRECTION('',(0.,-1.)); +#23087 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23088 = PCURVE('',#22932,#23089); +#23089 = DEFINITIONAL_REPRESENTATION('',(#23090),#23094); +#23090 = LINE('',#23091,#23092); +#23091 = CARTESIAN_POINT('',(-0.486918399039,-7.105427357601E-15)); +#23092 = VECTOR('',#23093,1.); +#23093 = DIRECTION('',(0.,-1.)); +#23094 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23095 = ORIENTED_EDGE('',*,*,#22838,.T.); +#23096 = ORIENTED_EDGE('',*,*,#23097,.F.); +#23097 = EDGE_CURVE('',#23098,#22780,#23100,.T.); +#23098 = VERTEX_POINT('',#23099); +#23099 = CARTESIAN_POINT('',(-58.11198325875,18.347352920869,4.5)); +#23100 = SURFACE_CURVE('',#23101,(#23105,#23112),.PCURVE_S1.); +#23101 = LINE('',#23102,#23103); +#23102 = CARTESIAN_POINT('',(-58.11198325875,18.347352920869,19.8)); +#23103 = VECTOR('',#23104,1.); +#23104 = DIRECTION('',(-9.14286432779E-17,6.39128997493E-16,1.)); +#23105 = PCURVE('',#22881,#23106); +#23106 = DEFINITIONAL_REPRESENTATION('',(#23107),#23111); +#23107 = LINE('',#23108,#23109); +#23108 = CARTESIAN_POINT('',(-0.349266996678,0.)); +#23109 = VECTOR('',#23110,1.); +#23110 = DIRECTION('',(0.,1.)); +#23111 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23112 = PCURVE('',#20680,#23113); +#23113 = DEFINITIONAL_REPRESENTATION('',(#23114),#23118); +#23114 = LINE('',#23115,#23116); +#23115 = CARTESIAN_POINT('',(38.122109819928,15.3)); +#23116 = VECTOR('',#23117,1.); +#23117 = DIRECTION('',(5.257801617149E-17,1.)); +#23118 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23119 = ORIENTED_EDGE('',*,*,#23120,.F.); +#23120 = EDGE_CURVE('',#23074,#23098,#23121,.T.); +#23121 = SURFACE_CURVE('',#23122,(#23127,#23134),.PCURVE_S1.); +#23122 = CIRCLE('',#23123,5.); +#23123 = AXIS2_PLACEMENT_3D('',#23124,#23125,#23126); +#23124 = CARTESIAN_POINT('',(-60.0593247085,13.742153546458,4.5)); +#23125 = DIRECTION('',(-3.266326329814E-29,-8.553453836232E-16,-1.)); +#23126 = DIRECTION('',(5.076540218662E-02,0.998710605702, + -8.542425061624E-16)); +#23127 = PCURVE('',#22881,#23128); +#23128 = DEFINITIONAL_REPRESENTATION('',(#23129),#23133); +#23129 = LINE('',#23130,#23131); +#23130 = CARTESIAN_POINT('',(6.28318530718,-15.3)); +#23131 = VECTOR('',#23132,1.); +#23132 = DIRECTION('',(-1.,0.)); +#23133 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23134 = PCURVE('',#21609,#23135); +#23135 = DEFINITIONAL_REPRESENTATION('',(#23136),#23140); +#23136 = CIRCLE('',#23137,5.); +#23137 = AXIS2_PLACEMENT_2D('',#23138,#23139); +#23138 = CARTESIAN_POINT('',(13.409324708525,28.892153546467)); +#23139 = DIRECTION('',(-5.076540218659E-02,0.998710605702)); +#23140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23141 = ADVANCED_FACE('',(#23142,#23218),#20680,.T.); +#23142 = FACE_BOUND('',#23143,.T.); +#23143 = EDGE_LOOP('',(#23144,#23145,#23146,#23169,#23197)); +#23144 = ORIENTED_EDGE('',*,*,#23097,.T.); +#23145 = ORIENTED_EDGE('',*,*,#22779,.T.); +#23146 = ORIENTED_EDGE('',*,*,#23147,.T.); +#23147 = EDGE_CURVE('',#22740,#23148,#23150,.T.); +#23148 = VERTEX_POINT('',#23149); +#23149 = CARTESIAN_POINT('',(-23.45789878249,3.693625770902,8.5)); +#23150 = SURFACE_CURVE('',#23151,(#23155,#23162),.PCURVE_S1.); +#23151 = LINE('',#23152,#23153); +#23152 = CARTESIAN_POINT('',(-32.8261474751,7.655056646637,8.5)); +#23153 = VECTOR('',#23154,1.); +#23154 = DIRECTION('',(0.921039874882,-0.38946828995,2.33863144889E-16) + ); +#23155 = PCURVE('',#20680,#23156); +#23156 = DEFINITIONAL_REPRESENTATION('',(#23157),#23161); +#23157 = LINE('',#23158,#23159); +#23158 = CARTESIAN_POINT('',(10.6685364479,4.)); +#23159 = VECTOR('',#23160,1.); +#23160 = DIRECTION('',(-1.,-4.668874281616E-17)); +#23161 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23162 = PCURVE('',#22763,#23163); +#23163 = DEFINITIONAL_REPRESENTATION('',(#23164),#23168); +#23164 = LINE('',#23165,#23166); +#23165 = CARTESIAN_POINT('',(7.673852524871,9.244943353375)); +#23166 = VECTOR('',#23167,1.); +#23167 = DIRECTION('',(0.921039874882,0.38946828995)); +#23168 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23169 = ORIENTED_EDGE('',*,*,#23170,.T.); +#23170 = EDGE_CURVE('',#23148,#23171,#23173,.T.); +#23171 = VERTEX_POINT('',#23172); +#23172 = CARTESIAN_POINT('',(-23.45789878249,3.693625770902,4.5)); +#23173 = SURFACE_CURVE('',#23174,(#23178,#23185),.PCURVE_S1.); +#23174 = LINE('',#23175,#23176); +#23175 = CARTESIAN_POINT('',(-23.45789878249,3.693625770902,12.15)); +#23176 = VECTOR('',#23177,1.); +#23177 = DIRECTION('',(-2.161879985228E-28,-6.004677426211E-16,-1.)); +#23178 = PCURVE('',#20680,#23179); +#23179 = DEFINITIONAL_REPRESENTATION('',(#23180),#23184); +#23180 = LINE('',#23181,#23182); +#23181 = CARTESIAN_POINT('',(0.497154135262,7.65)); +#23182 = VECTOR('',#23183,1.); +#23183 = DIRECTION('',(4.668874281635E-17,-1.)); +#23184 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23185 = PCURVE('',#23186,#23191); +#23186 = CYLINDRICAL_SURFACE('',#23187,0.75); +#23187 = AXIS2_PLACEMENT_3D('',#23188,#23189,#23190); +#23188 = CARTESIAN_POINT('',(-23.74999999995,3.002845864741,12.15)); +#23189 = DIRECTION('',(2.161111894458E-28,6.004677426211E-16,1.)); +#23190 = DIRECTION('',(0.833507135527,0.552508692262,-3.317636472213E-16 + )); +#23191 = DEFINITIONAL_REPRESENTATION('',(#23192),#23196); +#23192 = LINE('',#23193,#23194); +#23193 = CARTESIAN_POINT('',(6.868556356078,0.)); +#23194 = VECTOR('',#23195,1.); +#23195 = DIRECTION('',(0.,-1.)); +#23196 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23197 = ORIENTED_EDGE('',*,*,#23198,.T.); +#23198 = EDGE_CURVE('',#23171,#23098,#23199,.T.); +#23199 = SURFACE_CURVE('',#23200,(#23204,#23211),.PCURVE_S1.); +#23200 = LINE('',#23201,#23202); +#23201 = CARTESIAN_POINT('',(-35.12083806539,8.625382953388,4.5)); +#23202 = VECTOR('',#23203,1.); +#23203 = DIRECTION('',(-0.921039874882,0.38946828995,-3.331299038767E-16 + )); +#23204 = PCURVE('',#20680,#23205); +#23205 = DEFINITIONAL_REPRESENTATION('',(#23206),#23210); +#23206 = LINE('',#23207,#23208); +#23207 = CARTESIAN_POINT('',(13.159949309456,3.692048620872E-15)); +#23208 = VECTOR('',#23209,1.); +#23209 = DIRECTION('',(1.,-5.257801617149E-17)); +#23210 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23211 = PCURVE('',#21609,#23212); +#23212 = DEFINITIONAL_REPRESENTATION('',(#23213),#23217); +#23213 = LINE('',#23214,#23215); +#23214 = CARTESIAN_POINT('',(-11.52916193458,23.775382953398)); +#23215 = VECTOR('',#23216,1.); +#23216 = DIRECTION('',(0.921039874882,0.38946828995)); +#23217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23218 = FACE_BOUND('',#23219,.T.); +#23219 = EDGE_LOOP('',(#23220)); +#23220 = ORIENTED_EDGE('',*,*,#20643,.T.); +#23221 = ADVANCED_FACE('',(#23222),#22932,.F.); +#23222 = FACE_BOUND('',#23223,.F.); +#23223 = EDGE_LOOP('',(#23224,#23225,#23248,#23272,#23295,#23321)); +#23224 = ORIENTED_EDGE('',*,*,#22915,.F.); +#23225 = ORIENTED_EDGE('',*,*,#23226,.T.); +#23226 = EDGE_CURVE('',#22916,#23227,#23229,.T.); +#23227 = VERTEX_POINT('',#23228); +#23228 = CARTESIAN_POINT('',(-58.,23.300000000026,19.8)); +#23229 = SURFACE_CURVE('',#23230,(#23234,#23241),.PCURVE_S1.); +#23230 = LINE('',#23231,#23232); +#23231 = CARTESIAN_POINT('',(-58.,23.300000000026,19.8)); +#23232 = VECTOR('',#23233,1.); +#23233 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#23234 = PCURVE('',#22932,#23235); +#23235 = DEFINITIONAL_REPRESENTATION('',(#23236),#23240); +#23236 = LINE('',#23237,#23238); +#23237 = CARTESIAN_POINT('',(0.785398163397,-7.105427357601E-15)); +#23238 = VECTOR('',#23239,1.); +#23239 = DIRECTION('',(7.049035076985E-17,1.)); +#23240 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23241 = PCURVE('',#23058,#23242); +#23242 = DEFINITIONAL_REPRESENTATION('',(#23243),#23247); +#23243 = LINE('',#23244,#23245); +#23244 = CARTESIAN_POINT('',(6.999999999998,-9.348856532105E-14)); +#23245 = VECTOR('',#23246,1.); +#23246 = DIRECTION('',(0.,-1.)); +#23247 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23248 = ORIENTED_EDGE('',*,*,#23249,.T.); +#23249 = EDGE_CURVE('',#23227,#23250,#23252,.T.); +#23250 = VERTEX_POINT('',#23251); +#23251 = CARTESIAN_POINT('',(-63.,18.300000000026,19.8)); +#23252 = SURFACE_CURVE('',#23253,(#23258,#23265),.PCURVE_S1.); +#23253 = CIRCLE('',#23254,5.); +#23254 = AXIS2_PLACEMENT_3D('',#23255,#23256,#23257); +#23255 = CARTESIAN_POINT('',(-63.,23.300000000026,19.8)); +#23256 = DIRECTION('',(-3.250162547235E-29,-8.553453836232E-16,-1.)); +#23257 = DIRECTION('',(0.707106781187,-0.707106781187,6.048205210165E-16 + )); +#23258 = PCURVE('',#22932,#23259); +#23259 = DEFINITIONAL_REPRESENTATION('',(#23260),#23264); +#23260 = LINE('',#23261,#23262); +#23261 = CARTESIAN_POINT('',(6.28318530718,0.)); +#23262 = VECTOR('',#23263,1.); +#23263 = DIRECTION('',(-1.,0.)); +#23264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23265 = PCURVE('',#21855,#23266); +#23266 = DEFINITIONAL_REPRESENTATION('',(#23267),#23271); +#23267 = CIRCLE('',#23268,5.); +#23268 = AXIS2_PLACEMENT_2D('',#23269,#23270); +#23269 = CARTESIAN_POINT('',(-16.35000000002,-38.45000000003)); +#23270 = DIRECTION('',(0.707106781187,0.707106781186)); +#23271 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23272 = ORIENTED_EDGE('',*,*,#23273,.T.); +#23273 = EDGE_CURVE('',#23250,#23274,#23276,.T.); +#23274 = VERTEX_POINT('',#23275); +#23275 = CARTESIAN_POINT('',(-63.,18.300000000026,4.5)); +#23276 = SURFACE_CURVE('',#23277,(#23281,#23288),.PCURVE_S1.); +#23277 = LINE('',#23278,#23279); +#23278 = CARTESIAN_POINT('',(-63.,18.300000000026,19.8)); +#23279 = VECTOR('',#23280,1.); +#23280 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23281 = PCURVE('',#22932,#23282); +#23282 = DEFINITIONAL_REPRESENTATION('',(#23283),#23287); +#23283 = LINE('',#23284,#23285); +#23284 = CARTESIAN_POINT('',(-0.785398163397,-7.105427357601E-15)); +#23285 = VECTOR('',#23286,1.); +#23286 = DIRECTION('',(0.,-1.)); +#23287 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23288 = PCURVE('',#21883,#23289); +#23289 = DEFINITIONAL_REPRESENTATION('',(#23290),#23294); +#23290 = LINE('',#23291,#23292); +#23291 = CARTESIAN_POINT('',(5.,3.365067730408E-28)); +#23292 = VECTOR('',#23293,1.); +#23293 = DIRECTION('',(1.599442196756E-31,1.)); +#23294 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23295 = ORIENTED_EDGE('',*,*,#23296,.T.); +#23296 = EDGE_CURVE('',#23274,#23074,#23297,.T.); +#23297 = SURFACE_CURVE('',#23298,(#23303,#23310),.PCURVE_S1.); +#23298 = CIRCLE('',#23299,5.); +#23299 = AXIS2_PLACEMENT_3D('',#23300,#23301,#23302); +#23300 = CARTESIAN_POINT('',(-63.,23.300000000026,4.5)); +#23301 = DIRECTION('',(3.262065539087E-29,8.553453836232E-16,1.)); +#23302 = DIRECTION('',(0.707106781187,-0.707106781187,6.048205210165E-16 + )); +#23303 = PCURVE('',#22932,#23304); +#23304 = DEFINITIONAL_REPRESENTATION('',(#23305),#23309); +#23305 = LINE('',#23306,#23307); +#23306 = CARTESIAN_POINT('',(-6.28318530718,-15.3)); +#23307 = VECTOR('',#23308,1.); +#23308 = DIRECTION('',(1.,0.)); +#23309 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23310 = PCURVE('',#21609,#23311); +#23311 = DEFINITIONAL_REPRESENTATION('',(#23312),#23320); +#23312 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#23313,#23314,#23315,#23316 + ,#23317,#23318,#23319),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#23313 = CARTESIAN_POINT('',(12.81446609409,34.914466094103)); +#23314 = CARTESIAN_POINT('',(6.690741737132,41.038190451061)); +#23315 = CARTESIAN_POINT('',(15.055904774511,43.27962913148)); +#23316 = CARTESIAN_POINT('',(23.421067811889,45.5210678119)); +#23317 = CARTESIAN_POINT('',(21.179629131468,37.155904774522)); +#23318 = CARTESIAN_POINT('',(18.938190451047,28.790741737144)); +#23319 = CARTESIAN_POINT('',(12.81446609409,34.914466094103)); +#23320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23321 = ORIENTED_EDGE('',*,*,#23073,.F.); +#23322 = ADVANCED_FACE('',(#23323),#23338,.T.); +#23323 = FACE_BOUND('',#23324,.T.); +#23324 = EDGE_LOOP('',(#23325,#23365,#23388,#23412)); +#23325 = ORIENTED_EDGE('',*,*,#23326,.F.); +#23326 = EDGE_CURVE('',#23327,#23329,#23331,.T.); +#23327 = VERTEX_POINT('',#23328); +#23328 = CARTESIAN_POINT('',(-22.99999999997,18.517172932128,4.5)); +#23329 = VERTEX_POINT('',#23330); +#23330 = CARTESIAN_POINT('',(-25.77893657987,16.675093182362,4.5)); +#23331 = SURFACE_CURVE('',#23332,(#23337,#23349),.PCURVE_S1.); +#23332 = CIRCLE('',#23333,2.); +#23333 = AXIS2_PLACEMENT_3D('',#23334,#23335,#23336); +#23334 = CARTESIAN_POINT('',(-24.99999999997,18.517172932127,4.5)); +#23335 = DIRECTION('',(-3.265169039023E-29,-8.553453836232E-16,-1.)); +#23336 = DIRECTION('',(0.552508692262,-0.833507135527,7.129364805902E-16 + )); +#23337 = PCURVE('',#23338,#23343); +#23338 = CYLINDRICAL_SURFACE('',#23339,2.); +#23339 = AXIS2_PLACEMENT_3D('',#23340,#23341,#23342); +#23340 = CARTESIAN_POINT('',(-24.99999999997,18.517172932127,12.15)); +#23341 = DIRECTION('',(-2.161111894458E-28,-6.004677426211E-16,-1.)); +#23342 = DIRECTION('',(0.552508692262,-0.833507135527,5.004941481285E-16 + )); +#23343 = DEFINITIONAL_REPRESENTATION('',(#23344),#23348); +#23344 = LINE('',#23345,#23346); +#23345 = CARTESIAN_POINT('',(-2.6645352591E-15,7.65)); +#23346 = VECTOR('',#23347,1.); +#23347 = DIRECTION('',(1.,0.)); +#23348 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23349 = PCURVE('',#23350,#23355); +#23350 = PLANE('',#23351); +#23351 = AXIS2_PLACEMENT_3D('',#23352,#23353,#23354); +#23352 = CARTESIAN_POINT('',(-46.64999999997,15.15000000001,4.5)); +#23353 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#23354 = DIRECTION('',(-1.,-3.819991382918E-14,6.534401951903E-29)); +#23355 = DEFINITIONAL_REPRESENTATION('',(#23356),#23364); +#23356 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#23357,#23358,#23359,#23360 + ,#23361,#23362,#23363),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#23357 = CARTESIAN_POINT('',(-22.75501738453,-1.700158661061)); +#23358 = CARTESIAN_POINT('',(-19.86766397012,0.213787592181)); +#23359 = CARTESIAN_POINT('',(-19.65381460054,-3.243706941022)); +#23360 = CARTESIAN_POINT('',(-19.43996523096,-6.701201474225)); +#23361 = CARTESIAN_POINT('',(-22.54116801495,-5.157653194264)); +#23362 = CARTESIAN_POINT('',(-25.64237079894,-3.614104914304)); +#23363 = CARTESIAN_POINT('',(-22.75501738453,-1.700158661061)); +#23364 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23365 = ORIENTED_EDGE('',*,*,#23366,.F.); +#23366 = EDGE_CURVE('',#23367,#23327,#23369,.T.); +#23367 = VERTEX_POINT('',#23368); +#23368 = CARTESIAN_POINT('',(-22.99999999997,18.517172932128,8.5)); +#23369 = SURFACE_CURVE('',#23370,(#23374,#23381),.PCURVE_S1.); +#23370 = LINE('',#23371,#23372); +#23371 = CARTESIAN_POINT('',(-22.99999999997,18.517172932128,12.15)); +#23372 = VECTOR('',#23373,1.); +#23373 = DIRECTION('',(-2.161111894458E-28,-6.004677426211E-16,-1.)); +#23374 = PCURVE('',#23338,#23375); +#23375 = DEFINITIONAL_REPRESENTATION('',(#23376),#23380); +#23376 = LINE('',#23377,#23378); +#23377 = CARTESIAN_POINT('',(5.297760029283,0.)); +#23378 = VECTOR('',#23379,1.); +#23379 = DIRECTION('',(-2.22044604925E-16,1.)); +#23380 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23381 = PCURVE('',#20548,#23382); +#23382 = DEFINITIONAL_REPRESENTATION('',(#23383),#23387); +#23383 = LINE('',#23384,#23385); +#23384 = CARTESIAN_POINT('',(-18.51717293212,7.65)); +#23385 = VECTOR('',#23386,1.); +#23386 = DIRECTION('',(-2.548776410021E-16,1.)); +#23387 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23388 = ORIENTED_EDGE('',*,*,#23389,.T.); +#23389 = EDGE_CURVE('',#23367,#23390,#23392,.T.); +#23390 = VERTEX_POINT('',#23391); +#23391 = CARTESIAN_POINT('',(-25.77893657987,16.675093182362,8.5)); +#23392 = SURFACE_CURVE('',#23393,(#23398,#23405),.PCURVE_S1.); +#23393 = CIRCLE('',#23394,2.); +#23394 = AXIS2_PLACEMENT_3D('',#23395,#23396,#23397); +#23395 = CARTESIAN_POINT('',(-24.99999999997,18.517172932127,8.5)); +#23396 = DIRECTION('',(-4.236921020076E-29,-6.004677426212E-16,-1.)); +#23397 = DIRECTION('',(0.552508692262,-0.833507135527,5.004941481287E-16 + )); +#23398 = PCURVE('',#23338,#23399); +#23399 = DEFINITIONAL_REPRESENTATION('',(#23400),#23404); +#23400 = LINE('',#23401,#23402); +#23401 = CARTESIAN_POINT('',(-1.7763568394E-15,3.65)); +#23402 = VECTOR('',#23403,1.); +#23403 = DIRECTION('',(1.,0.)); +#23404 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23405 = PCURVE('',#22763,#23406); +#23406 = DEFINITIONAL_REPRESENTATION('',(#23407),#23411); +#23407 = CIRCLE('',#23408,2.); +#23408 = AXIS2_PLACEMENT_2D('',#23409,#23410); +#23409 = CARTESIAN_POINT('',(15.500000000009,-1.617172932114)); +#23410 = DIRECTION('',(0.552508692262,0.833507135527)); +#23411 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23412 = ORIENTED_EDGE('',*,*,#23413,.F.); +#23413 = EDGE_CURVE('',#23329,#23390,#23414,.T.); +#23414 = SURFACE_CURVE('',#23415,(#23419,#23426),.PCURVE_S1.); +#23415 = LINE('',#23416,#23417); +#23416 = CARTESIAN_POINT('',(-25.77893657987,16.675093182362,12.15)); +#23417 = VECTOR('',#23418,1.); +#23418 = DIRECTION('',(2.161111894458E-28,6.004677426211E-16,1.)); +#23419 = PCURVE('',#23338,#23420); +#23420 = DEFINITIONAL_REPRESENTATION('',(#23421),#23425); +#23421 = LINE('',#23422,#23423); +#23422 = CARTESIAN_POINT('',(7.268610585076,0.)); +#23423 = VECTOR('',#23424,1.); +#23424 = DIRECTION('',(-2.22044604925E-16,-1.)); +#23425 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23426 = PCURVE('',#20817,#23427); +#23427 = DEFINITIONAL_REPRESENTATION('',(#23428),#23432); +#23428 = LINE('',#23429,#23430); +#23429 = CARTESIAN_POINT('',(34.983353380057,7.65)); +#23430 = VECTOR('',#23431,1.); +#23431 = DIRECTION('',(4.668874281635E-17,1.)); +#23432 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23433 = ADVANCED_FACE('',(#23434),#23350,.F.); +#23434 = FACE_BOUND('',#23435,.T.); +#23435 = EDGE_LOOP('',(#23436,#23437,#23460,#23483)); +#23436 = ORIENTED_EDGE('',*,*,#23326,.T.); +#23437 = ORIENTED_EDGE('',*,*,#23438,.F.); +#23438 = EDGE_CURVE('',#23439,#23329,#23441,.T.); +#23439 = VERTEX_POINT('',#23440); +#23440 = CARTESIAN_POINT('',(-58.,30.300000000024,4.5)); +#23441 = SURFACE_CURVE('',#23442,(#23446,#23453),.PCURVE_S1.); +#23442 = LINE('',#23443,#23444); +#23443 = CARTESIAN_POINT('',(-50.46854311513,27.115269660137,4.5)); +#23444 = VECTOR('',#23445,1.); +#23445 = DIRECTION('',(0.921039874882,-0.38946828995,3.331299038767E-16) + ); +#23446 = PCURVE('',#23350,#23447); +#23447 = DEFINITIONAL_REPRESENTATION('',(#23448),#23452); +#23448 = LINE('',#23449,#23450); +#23449 = CARTESIAN_POINT('',(3.818543115158,-11.96526966012)); +#23450 = VECTOR('',#23451,1.); +#23451 = DIRECTION('',(-0.921039874882,0.38946828995)); +#23452 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23453 = PCURVE('',#20817,#23454); +#23454 = DEFINITIONAL_REPRESENTATION('',(#23455),#23459); +#23455 = LINE('',#23456,#23457); +#23456 = CARTESIAN_POINT('',(8.177123586344,-2.294107458147E-15)); +#23457 = VECTOR('',#23458,1.); +#23458 = DIRECTION('',(1.,5.257801617149E-17)); +#23459 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23460 = ORIENTED_EDGE('',*,*,#23461,.F.); +#23461 = EDGE_CURVE('',#23462,#23439,#23464,.T.); +#23462 = VERTEX_POINT('',#23463); +#23463 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,4.5)); +#23464 = SURFACE_CURVE('',#23465,(#23469,#23476),.PCURVE_S1.); +#23465 = LINE('',#23466,#23467); +#23466 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,4.5)); +#23467 = VECTOR('',#23468,1.); +#23468 = DIRECTION('',(-1.,7.556212847502E-13,-6.138072223278E-28)); +#23469 = PCURVE('',#23350,#23470); +#23470 = DEFINITIONAL_REPRESENTATION('',(#23471),#23475); +#23471 = LINE('',#23472,#23473); +#23472 = CARTESIAN_POINT('',(-23.65,-15.14999999998)); +#23473 = VECTOR('',#23474,1.); +#23474 = DIRECTION('',(1.,-7.938211985794E-13)); +#23475 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23476 = PCURVE('',#20767,#23477); +#23477 = DEFINITIONAL_REPRESENTATION('',(#23478),#23482); +#23478 = LINE('',#23479,#23480); +#23479 = CARTESIAN_POINT('',(-8.039904882109E-28,15.3)); +#23480 = VECTOR('',#23481,1.); +#23481 = DIRECTION('',(1.,0.)); +#23482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23483 = ORIENTED_EDGE('',*,*,#23484,.F.); +#23484 = EDGE_CURVE('',#23327,#23462,#23485,.T.); +#23485 = SURFACE_CURVE('',#23486,(#23490,#23497),.PCURVE_S1.); +#23486 = LINE('',#23487,#23488); +#23487 = CARTESIAN_POINT('',(-22.99999999995,-5.02493206569E-15,4.5)); +#23488 = VECTOR('',#23489,1.); +#23489 = DIRECTION('',(-7.197229586486E-13,1.,-8.553453836232E-16)); +#23490 = PCURVE('',#23350,#23491); +#23491 = DEFINITIONAL_REPRESENTATION('',(#23492),#23496); +#23492 = LINE('',#23493,#23494); +#23493 = CARTESIAN_POINT('',(-23.65000000002,15.150000000011)); +#23494 = VECTOR('',#23495,1.); +#23495 = DIRECTION('',(6.815230448195E-13,-1.)); +#23496 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23497 = PCURVE('',#20548,#23498); +#23498 = DEFINITIONAL_REPRESENTATION('',(#23499),#23503); +#23499 = LINE('',#23500,#23501); +#23500 = CARTESIAN_POINT('',(-4.233144021558E-27,15.3)); +#23501 = VECTOR('',#23502,1.); +#23502 = DIRECTION('',(-1.,-9.860761315263E-31)); +#23503 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23504 = ADVANCED_FACE('',(#23505),#21883,.F.); +#23505 = FACE_BOUND('',#23506,.T.); +#23506 = EDGE_LOOP('',(#23507,#23508,#23529,#23530)); +#23507 = ORIENTED_EDGE('',*,*,#23273,.T.); +#23508 = ORIENTED_EDGE('',*,*,#23509,.T.); +#23509 = EDGE_CURVE('',#23274,#21868,#23510,.T.); +#23510 = SURFACE_CURVE('',#23511,(#23515,#23522),.PCURVE_S1.); +#23511 = LINE('',#23512,#23513); +#23512 = CARTESIAN_POINT('',(-58.,18.300000000026,4.5)); +#23513 = VECTOR('',#23514,1.); +#23514 = DIRECTION('',(-1.,-4.036620265772E-14,6.703700044843E-29)); +#23515 = PCURVE('',#21883,#23516); +#23516 = DEFINITIONAL_REPRESENTATION('',(#23517),#23521); +#23517 = LINE('',#23518,#23519); +#23518 = CARTESIAN_POINT('',(9.075544198625E-29,15.3)); +#23519 = VECTOR('',#23520,1.); +#23520 = DIRECTION('',(1.,0.)); +#23521 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23522 = PCURVE('',#21609,#23523); +#23523 = DEFINITIONAL_REPRESENTATION('',(#23524),#23528); +#23524 = LINE('',#23525,#23526); +#23525 = CARTESIAN_POINT('',(11.350000000023,33.450000000035)); +#23526 = VECTOR('',#23527,1.); +#23527 = DIRECTION('',(1.,-7.856118236527E-14)); +#23528 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23529 = ORIENTED_EDGE('',*,*,#21867,.F.); +#23530 = ORIENTED_EDGE('',*,*,#23531,.F.); +#23531 = EDGE_CURVE('',#23250,#21840,#23532,.T.); +#23532 = SURFACE_CURVE('',#23533,(#23537,#23544),.PCURVE_S1.); +#23533 = LINE('',#23534,#23535); +#23534 = CARTESIAN_POINT('',(-58.,18.300000000026,19.8)); +#23535 = VECTOR('',#23536,1.); +#23536 = DIRECTION('',(-1.,-4.036620265772E-14,6.703700044843E-29)); +#23537 = PCURVE('',#21883,#23538); +#23538 = DEFINITIONAL_REPRESENTATION('',(#23539),#23543); +#23539 = LINE('',#23540,#23541); +#23540 = CARTESIAN_POINT('',(0.,0.)); +#23541 = VECTOR('',#23542,1.); +#23542 = DIRECTION('',(1.,0.)); +#23543 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23544 = PCURVE('',#21855,#23545); +#23545 = DEFINITIONAL_REPRESENTATION('',(#23546),#23550); +#23546 = LINE('',#23547,#23548); +#23547 = CARTESIAN_POINT('',(-11.35000000002,-33.45000000003)); +#23548 = VECTOR('',#23549,1.); +#23549 = DIRECTION('',(-1.,7.856118236527E-14)); +#23550 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23551 = ADVANCED_FACE('',(#23552),#23186,.T.); +#23552 = FACE_BOUND('',#23553,.T.); +#23553 = EDGE_LOOP('',(#23554,#23578,#23579,#23603)); +#23554 = ORIENTED_EDGE('',*,*,#23555,.F.); +#23555 = EDGE_CURVE('',#23171,#23556,#23558,.T.); +#23556 = VERTEX_POINT('',#23557); +#23557 = CARTESIAN_POINT('',(-22.99999999995,3.002845864741,4.5)); +#23558 = SURFACE_CURVE('',#23559,(#23564,#23571),.PCURVE_S1.); +#23559 = CIRCLE('',#23560,0.75); +#23560 = AXIS2_PLACEMENT_3D('',#23561,#23562,#23563); +#23561 = CARTESIAN_POINT('',(-23.74999999995,3.002845864741,4.5)); +#23562 = DIRECTION('',(-3.265639282634E-29,-8.553453836232E-16,-1.)); +#23563 = DIRECTION('',(0.833507135527,0.552508692262,-4.725857593381E-16 + )); +#23564 = PCURVE('',#23186,#23565); +#23565 = DEFINITIONAL_REPRESENTATION('',(#23566),#23570); +#23566 = LINE('',#23567,#23568); +#23567 = CARTESIAN_POINT('',(12.566370614359,-7.65)); +#23568 = VECTOR('',#23569,1.); +#23569 = DIRECTION('',(-1.,0.)); +#23570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23571 = PCURVE('',#21609,#23572); +#23572 = DEFINITIONAL_REPRESENTATION('',(#23573),#23577); +#23573 = CIRCLE('',#23574,0.75); +#23574 = AXIS2_PLACEMENT_2D('',#23575,#23576); +#23575 = CARTESIAN_POINT('',(-22.90000000001,18.152845864752)); +#23576 = DIRECTION('',(-0.833507135527,0.552508692262)); +#23577 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23578 = ORIENTED_EDGE('',*,*,#23170,.F.); +#23579 = ORIENTED_EDGE('',*,*,#23580,.T.); +#23580 = EDGE_CURVE('',#23148,#23581,#23583,.T.); +#23581 = VERTEX_POINT('',#23582); +#23582 = CARTESIAN_POINT('',(-22.99999999995,3.002845864741,8.5)); +#23583 = SURFACE_CURVE('',#23584,(#23589,#23596),.PCURVE_S1.); +#23584 = CIRCLE('',#23585,0.75); +#23585 = AXIS2_PLACEMENT_3D('',#23586,#23587,#23588); +#23586 = CARTESIAN_POINT('',(-23.74999999995,3.002845864741,8.5)); +#23587 = DIRECTION('',(-4.237219942825E-29,-6.004677426212E-16,-1.)); +#23588 = DIRECTION('',(0.833507135527,0.552508692262,-3.317636472212E-16 + )); +#23589 = PCURVE('',#23186,#23590); +#23590 = DEFINITIONAL_REPRESENTATION('',(#23591),#23595); +#23591 = LINE('',#23592,#23593); +#23592 = CARTESIAN_POINT('',(12.566370614359,-3.65)); +#23593 = VECTOR('',#23594,1.); +#23594 = DIRECTION('',(-1.,0.)); +#23595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23596 = PCURVE('',#22763,#23597); +#23597 = DEFINITIONAL_REPRESENTATION('',(#23598),#23602); +#23598 = CIRCLE('',#23599,0.75); +#23599 = AXIS2_PLACEMENT_2D('',#23600,#23601); +#23600 = CARTESIAN_POINT('',(16.750000000019,13.897154135272)); +#23601 = DIRECTION('',(0.833507135527,-0.552508692262)); +#23602 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23603 = ORIENTED_EDGE('',*,*,#23604,.F.); +#23604 = EDGE_CURVE('',#23556,#23581,#23605,.T.); +#23605 = SURFACE_CURVE('',#23606,(#23610,#23617),.PCURVE_S1.); +#23606 = LINE('',#23607,#23608); +#23607 = CARTESIAN_POINT('',(-22.99999999995,3.002845864741,12.15)); +#23608 = VECTOR('',#23609,1.); +#23609 = DIRECTION('',(2.161111894458E-28,6.004677426211E-16,1.)); +#23610 = PCURVE('',#23186,#23611); +#23611 = DEFINITIONAL_REPRESENTATION('',(#23612),#23616); +#23612 = LINE('',#23613,#23614); +#23613 = CARTESIAN_POINT('',(5.697814258281,0.)); +#23614 = VECTOR('',#23615,1.); +#23615 = DIRECTION('',(0.,1.)); +#23616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23617 = PCURVE('',#20548,#23618); +#23618 = DEFINITIONAL_REPRESENTATION('',(#23619),#23623); +#23619 = LINE('',#23620,#23621); +#23620 = CARTESIAN_POINT('',(-3.002845864741,7.65)); +#23621 = VECTOR('',#23622,1.); +#23622 = DIRECTION('',(2.548776410021E-16,-1.)); +#23623 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23624 = ADVANCED_FACE('',(#23625),#20520,.T.); +#23625 = FACE_BOUND('',#23626,.T.); +#23626 = EDGE_LOOP('',(#23627,#23653,#23674,#23675)); +#23627 = ORIENTED_EDGE('',*,*,#23628,.F.); +#23628 = EDGE_CURVE('',#23629,#23631,#23633,.T.); +#23629 = VERTEX_POINT('',#23630); +#23630 = CARTESIAN_POINT('',(-22.99999999995,2.749999999997,4.5)); +#23631 = VERTEX_POINT('',#23632); +#23632 = CARTESIAN_POINT('',(-23.74999999995,1.999999999997,4.5)); +#23633 = SURFACE_CURVE('',#23634,(#23639,#23646),.PCURVE_S1.); +#23634 = CIRCLE('',#23635,0.75); +#23635 = AXIS2_PLACEMENT_3D('',#23636,#23637,#23638); +#23636 = CARTESIAN_POINT('',(-23.74999999995,2.749999999997,4.5)); +#23637 = DIRECTION('',(-3.25945318859E-29,-8.553453836232E-16,-1.)); +#23638 = DIRECTION('',(0.707106781187,-0.707106781186,6.048205210163E-16 + )); +#23639 = PCURVE('',#20520,#23640); +#23640 = DEFINITIONAL_REPRESENTATION('',(#23641),#23645); +#23641 = LINE('',#23642,#23643); +#23642 = CARTESIAN_POINT('',(-6.28318530718,15.3)); +#23643 = VECTOR('',#23644,1.); +#23644 = DIRECTION('',(1.,0.)); +#23645 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23646 = PCURVE('',#21609,#23647); +#23647 = DEFINITIONAL_REPRESENTATION('',(#23648),#23652); +#23648 = CIRCLE('',#23649,0.75); +#23649 = AXIS2_PLACEMENT_2D('',#23650,#23651); +#23650 = CARTESIAN_POINT('',(-22.90000000001,17.900000000008)); +#23651 = DIRECTION('',(-0.707106781187,-0.707106781186)); +#23652 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23653 = ORIENTED_EDGE('',*,*,#23654,.F.); +#23654 = EDGE_CURVE('',#20500,#23629,#23655,.T.); +#23655 = SURFACE_CURVE('',#23656,(#23660,#23667),.PCURVE_S1.); +#23656 = LINE('',#23657,#23658); +#23657 = CARTESIAN_POINT('',(-22.99999999995,2.749999999997,19.8)); +#23658 = VECTOR('',#23659,1.); +#23659 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23660 = PCURVE('',#20520,#23661); +#23661 = DEFINITIONAL_REPRESENTATION('',(#23662),#23666); +#23662 = LINE('',#23663,#23664); +#23663 = CARTESIAN_POINT('',(-0.785398163398,0.)); +#23664 = VECTOR('',#23665,1.); +#23665 = DIRECTION('',(4.440892098501E-16,1.)); +#23666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23667 = PCURVE('',#20548,#23668); +#23668 = DEFINITIONAL_REPRESENTATION('',(#23669),#23673); +#23669 = LINE('',#23670,#23671); +#23670 = CARTESIAN_POINT('',(-2.749999999997,-2.352199804961E-15)); +#23671 = VECTOR('',#23672,1.); +#23672 = DIRECTION('',(-9.860761315263E-31,1.)); +#23673 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23674 = ORIENTED_EDGE('',*,*,#20499,.T.); +#23675 = ORIENTED_EDGE('',*,*,#23676,.F.); +#23676 = EDGE_CURVE('',#23631,#20477,#23677,.T.); +#23677 = SURFACE_CURVE('',#23678,(#23682,#23689),.PCURVE_S1.); +#23678 = LINE('',#23679,#23680); +#23679 = CARTESIAN_POINT('',(-23.74999999995,1.999999999997,19.8)); +#23680 = VECTOR('',#23681,1.); +#23681 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#23682 = PCURVE('',#20520,#23683); +#23683 = DEFINITIONAL_REPRESENTATION('',(#23684),#23688); +#23684 = LINE('',#23685,#23686); +#23685 = CARTESIAN_POINT('',(0.785398163398,0.)); +#23686 = VECTOR('',#23687,1.); +#23687 = DIRECTION('',(-4.440892098501E-16,-1.)); +#23688 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23689 = PCURVE('',#20373,#23690); +#23690 = DEFINITIONAL_REPRESENTATION('',(#23691),#23695); +#23691 = LINE('',#23692,#23693); +#23692 = CARTESIAN_POINT('',(14.950000000041,-9.780007949217E-28)); +#23693 = VECTOR('',#23694,1.); +#23694 = DIRECTION('',(1.599442196756E-31,-1.)); +#23695 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23696 = ADVANCED_FACE('',(#23697,#23802),#20373,.F.); +#23697 = FACE_BOUND('',#23698,.T.); +#23698 = EDGE_LOOP('',(#23699,#23700,#23701,#23702,#23725,#23753,#23781) + ); +#23699 = ORIENTED_EDGE('',*,*,#23676,.T.); +#23700 = ORIENTED_EDGE('',*,*,#20476,.F.); +#23701 = ORIENTED_EDGE('',*,*,#20349,.T.); +#23702 = ORIENTED_EDGE('',*,*,#23703,.F.); +#23703 = EDGE_CURVE('',#23704,#20352,#23706,.T.); +#23704 = VERTEX_POINT('',#23705); +#23705 = CARTESIAN_POINT('',(-36.7,1.999999999996,18.3)); +#23706 = SURFACE_CURVE('',#23707,(#23711,#23718),.PCURVE_S1.); +#23707 = LINE('',#23708,#23709); +#23708 = CARTESIAN_POINT('',(-36.7,1.999999999996,19.8)); +#23709 = VECTOR('',#23710,1.); +#23710 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23711 = PCURVE('',#20373,#23712); +#23712 = DEFINITIONAL_REPRESENTATION('',(#23713),#23717); +#23713 = LINE('',#23714,#23715); +#23714 = CARTESIAN_POINT('',(2.,-1.309181675574E-28)); +#23715 = VECTOR('',#23716,1.); +#23716 = DIRECTION('',(-1.599442196756E-31,1.)); +#23717 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23718 = PCURVE('',#20460,#23719); +#23719 = DEFINITIONAL_REPRESENTATION('',(#23720),#23724); +#23720 = LINE('',#23721,#23722); +#23721 = CARTESIAN_POINT('',(3.999999999993,-3.421381534486E-15)); +#23722 = VECTOR('',#23723,1.); +#23723 = DIRECTION('',(9.860761315263E-31,1.)); +#23724 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23725 = ORIENTED_EDGE('',*,*,#23726,.F.); +#23726 = EDGE_CURVE('',#23727,#23704,#23729,.T.); +#23727 = VERTEX_POINT('',#23728); +#23728 = CARTESIAN_POINT('',(-38.7,1.999999999996,18.3)); +#23729 = SURFACE_CURVE('',#23730,(#23734,#23741),.PCURVE_S1.); +#23730 = LINE('',#23731,#23732); +#23731 = CARTESIAN_POINT('',(-37.775,1.999999999996,18.3)); +#23732 = VECTOR('',#23733,1.); +#23733 = DIRECTION('',(1.,3.847746958534E-14,-6.561339906108E-29)); +#23734 = PCURVE('',#20373,#23735); +#23735 = DEFINITIONAL_REPRESENTATION('',(#23736),#23740); +#23736 = LINE('',#23737,#23738); +#23737 = CARTESIAN_POINT('',(0.925,1.5)); +#23738 = VECTOR('',#23739,1.); +#23739 = DIRECTION('',(1.,1.919177270007E-31)); +#23740 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23741 = PCURVE('',#23742,#23747); +#23742 = PLANE('',#23743); +#23743 = AXIS2_PLACEMENT_3D('',#23744,#23745,#23746); +#23744 = CARTESIAN_POINT('',(-36.85,-2.299999999996,18.3)); +#23745 = DIRECTION('',(-2.826996393094E-29,-7.401486830834E-16,-1.)); +#23746 = DIRECTION('',(-1.,3.819497970755E-14,2.24207754292E-44)); +#23747 = DEFINITIONAL_REPRESENTATION('',(#23748),#23752); +#23748 = LINE('',#23749,#23750); +#23749 = CARTESIAN_POINT('',(0.925,4.299999999992)); +#23750 = VECTOR('',#23751,1.); +#23751 = DIRECTION('',(-1.,7.667244929289E-14)); +#23752 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23753 = ORIENTED_EDGE('',*,*,#23754,.T.); +#23754 = EDGE_CURVE('',#23727,#23755,#23757,.T.); +#23755 = VERTEX_POINT('',#23756); +#23756 = CARTESIAN_POINT('',(-38.7,1.999999999996,4.5)); +#23757 = SURFACE_CURVE('',#23758,(#23762,#23769),.PCURVE_S1.); +#23758 = LINE('',#23759,#23760); +#23759 = CARTESIAN_POINT('',(-38.7,1.999999999996,19.8)); +#23760 = VECTOR('',#23761,1.); +#23761 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23762 = PCURVE('',#20373,#23763); +#23763 = DEFINITIONAL_REPRESENTATION('',(#23764),#23768); +#23764 = LINE('',#23765,#23766); +#23765 = CARTESIAN_POINT('',(0.,0.)); +#23766 = VECTOR('',#23767,1.); +#23767 = DIRECTION('',(-1.599442196756E-31,1.)); +#23768 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23769 = PCURVE('',#23770,#23775); +#23770 = PLANE('',#23771); +#23771 = AXIS2_PLACEMENT_3D('',#23772,#23773,#23774); +#23772 = CARTESIAN_POINT('',(-38.7,4.599999999996,19.8)); +#23773 = DIRECTION('',(1.,3.86269226848E-14,-6.570925957245E-29)); +#23774 = DIRECTION('',(3.86269226848E-14,-1.,8.553453836232E-16)); +#23775 = DEFINITIONAL_REPRESENTATION('',(#23776),#23780); +#23776 = LINE('',#23777,#23778); +#23777 = CARTESIAN_POINT('',(2.6,2.22389799742E-15)); +#23778 = VECTOR('',#23779,1.); +#23779 = DIRECTION('',(0.,1.)); +#23780 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23781 = ORIENTED_EDGE('',*,*,#23782,.T.); +#23782 = EDGE_CURVE('',#23755,#23631,#23783,.T.); +#23783 = SURFACE_CURVE('',#23784,(#23788,#23795),.PCURVE_S1.); +#23784 = LINE('',#23785,#23786); +#23785 = CARTESIAN_POINT('',(-36.7,1.999999999996,4.5)); +#23786 = VECTOR('',#23787,1.); +#23787 = DIRECTION('',(1.,3.847746958534E-14,-6.542148133408E-29)); +#23788 = PCURVE('',#20373,#23789); +#23789 = DEFINITIONAL_REPRESENTATION('',(#23790),#23794); +#23790 = LINE('',#23791,#23792); +#23791 = CARTESIAN_POINT('',(2.,15.3)); +#23792 = VECTOR('',#23793,1.); +#23793 = DIRECTION('',(1.,0.)); +#23794 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23795 = PCURVE('',#21609,#23796); +#23796 = DEFINITIONAL_REPRESENTATION('',(#23797),#23801); +#23797 = LINE('',#23798,#23799); +#23798 = CARTESIAN_POINT('',(-9.949999999978,17.150000000007)); +#23799 = VECTOR('',#23800,1.); +#23800 = DIRECTION('',(-1.,7.667244929289E-14)); +#23801 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23802 = FACE_BOUND('',#23803,.T.); +#23803 = EDGE_LOOP('',(#23804)); +#23804 = ORIENTED_EDGE('',*,*,#20697,.T.); +#23805 = ADVANCED_FACE('',(#23806,#23853),#20817,.T.); +#23806 = FACE_BOUND('',#23807,.T.); +#23807 = EDGE_LOOP('',(#23808,#23809,#23830,#23831,#23852)); +#23808 = ORIENTED_EDGE('',*,*,#23413,.T.); +#23809 = ORIENTED_EDGE('',*,*,#23810,.F.); +#23810 = EDGE_CURVE('',#22977,#23390,#23811,.T.); +#23811 = SURFACE_CURVE('',#23812,(#23816,#23823),.PCURVE_S1.); +#23812 = LINE('',#23813,#23814); +#23813 = CARTESIAN_POINT('',(-58.,30.300000000024,8.5)); +#23814 = VECTOR('',#23815,1.); +#23815 = DIRECTION('',(0.921039874882,-0.38946828995,2.805518877052E-16) + ); +#23816 = PCURVE('',#20817,#23817); +#23817 = DEFINITIONAL_REPRESENTATION('',(#23818),#23822); +#23818 = LINE('',#23819,#23820); +#23819 = CARTESIAN_POINT('',(-2.61461770345E-16,4.)); +#23820 = VECTOR('',#23821,1.); +#23821 = DIRECTION('',(1.,-1.479114197289E-31)); +#23822 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23823 = PCURVE('',#22763,#23824); +#23824 = DEFINITIONAL_REPRESENTATION('',(#23825),#23829); +#23825 = LINE('',#23826,#23827); +#23826 = CARTESIAN_POINT('',(-17.50000000002,-13.40000000001)); +#23827 = VECTOR('',#23828,1.); +#23828 = DIRECTION('',(0.921039874882,0.38946828995)); +#23829 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23830 = ORIENTED_EDGE('',*,*,#22974,.F.); +#23831 = ORIENTED_EDGE('',*,*,#23832,.T.); +#23832 = EDGE_CURVE('',#22975,#23439,#23833,.T.); +#23833 = SURFACE_CURVE('',#23834,(#23838,#23845),.PCURVE_S1.); +#23834 = LINE('',#23835,#23836); +#23835 = CARTESIAN_POINT('',(-58.,30.300000000024,19.8)); +#23836 = VECTOR('',#23837,1.); +#23837 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23838 = PCURVE('',#20817,#23839); +#23839 = DEFINITIONAL_REPRESENTATION('',(#23840),#23844); +#23840 = LINE('',#23841,#23842); +#23841 = CARTESIAN_POINT('',(1.525105239558E-15,15.3)); +#23842 = VECTOR('',#23843,1.); +#23843 = DIRECTION('',(5.257801617149E-17,-1.)); +#23844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23845 = PCURVE('',#20767,#23846); +#23846 = DEFINITIONAL_REPRESENTATION('',(#23847),#23851); +#23847 = LINE('',#23848,#23849); +#23848 = CARTESIAN_POINT('',(35.000000000021,-2.148381697179E-26)); +#23849 = VECTOR('',#23850,1.); +#23850 = DIRECTION('',(1.599442196757E-31,1.)); +#23851 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23852 = ORIENTED_EDGE('',*,*,#23438,.T.); +#23853 = FACE_BOUND('',#23854,.T.); +#23854 = EDGE_LOOP('',(#23855)); +#23855 = ORIENTED_EDGE('',*,*,#20780,.T.); +#23856 = ADVANCED_FACE('',(#23857),#22763,.T.); +#23857 = FACE_BOUND('',#23858,.T.); +#23858 = EDGE_LOOP('',(#23859,#23860,#23861,#23862,#23863,#23884,#23885) + ); +#23859 = ORIENTED_EDGE('',*,*,#22739,.T.); +#23860 = ORIENTED_EDGE('',*,*,#23022,.T.); +#23861 = ORIENTED_EDGE('',*,*,#23810,.T.); +#23862 = ORIENTED_EDGE('',*,*,#23389,.F.); +#23863 = ORIENTED_EDGE('',*,*,#23864,.T.); +#23864 = EDGE_CURVE('',#23367,#23581,#23865,.T.); +#23865 = SURFACE_CURVE('',#23866,(#23870,#23877),.PCURVE_S1.); +#23866 = LINE('',#23867,#23868); +#23867 = CARTESIAN_POINT('',(-22.99999999996,8.450000000012,8.5)); +#23868 = VECTOR('',#23869,1.); +#23869 = DIRECTION('',(7.197229586486E-13,-1.,6.004677426212E-16)); +#23870 = PCURVE('',#22763,#23871); +#23871 = DEFINITIONAL_REPRESENTATION('',(#23872),#23876); +#23872 = LINE('',#23873,#23874); +#23873 = CARTESIAN_POINT('',(17.500000000015,8.45)); +#23874 = VECTOR('',#23875,1.); +#23875 = DIRECTION('',(6.815230448195E-13,1.)); +#23876 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23877 = PCURVE('',#20548,#23878); +#23878 = DEFINITIONAL_REPRESENTATION('',(#23879),#23883); +#23879 = LINE('',#23880,#23881); +#23880 = CARTESIAN_POINT('',(-8.450000000012,11.3)); +#23881 = VECTOR('',#23882,1.); +#23882 = DIRECTION('',(1.,2.54877641002E-16)); +#23883 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23884 = ORIENTED_EDGE('',*,*,#23580,.F.); +#23885 = ORIENTED_EDGE('',*,*,#23147,.F.); +#23886 = ADVANCED_FACE('',(#23887),#23058,.F.); +#23887 = FACE_BOUND('',#23888,.T.); +#23888 = EDGE_LOOP('',(#23889,#23890,#23891,#23914)); +#23889 = ORIENTED_EDGE('',*,*,#23044,.T.); +#23890 = ORIENTED_EDGE('',*,*,#23226,.T.); +#23891 = ORIENTED_EDGE('',*,*,#23892,.F.); +#23892 = EDGE_CURVE('',#23893,#23227,#23895,.T.); +#23893 = VERTEX_POINT('',#23894); +#23894 = CARTESIAN_POINT('',(-58.,30.300000000024,19.8)); +#23895 = SURFACE_CURVE('',#23896,(#23900,#23907),.PCURVE_S1.); +#23896 = LINE('',#23897,#23898); +#23897 = CARTESIAN_POINT('',(-58.,30.300000000024,19.8)); +#23898 = VECTOR('',#23899,1.); +#23899 = DIRECTION('',(2.228671714288E-14,-1.,8.553453836232E-16)); +#23900 = PCURVE('',#23058,#23901); +#23901 = DEFINITIONAL_REPRESENTATION('',(#23902),#23906); +#23902 = LINE('',#23903,#23904); +#23903 = CARTESIAN_POINT('',(0.,0.)); +#23904 = VECTOR('',#23905,1.); +#23905 = DIRECTION('',(1.,0.)); +#23906 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23907 = PCURVE('',#21855,#23908); +#23908 = DEFINITIONAL_REPRESENTATION('',(#23909),#23913); +#23909 = LINE('',#23910,#23911); +#23910 = CARTESIAN_POINT('',(-11.35000000002,-45.45000000003)); +#23911 = VECTOR('',#23912,1.); +#23912 = DIRECTION('',(6.048169685043E-14,1.)); +#23913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23914 = ORIENTED_EDGE('',*,*,#23915,.T.); +#23915 = EDGE_CURVE('',#23893,#22975,#23916,.T.); +#23916 = SURFACE_CURVE('',#23917,(#23921,#23928),.PCURVE_S1.); +#23917 = LINE('',#23918,#23919); +#23918 = CARTESIAN_POINT('',(-58.,30.300000000024,19.8)); +#23919 = VECTOR('',#23920,1.); +#23920 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#23921 = PCURVE('',#23058,#23922); +#23922 = DEFINITIONAL_REPRESENTATION('',(#23923),#23927); +#23923 = LINE('',#23924,#23925); +#23924 = CARTESIAN_POINT('',(0.,0.)); +#23925 = VECTOR('',#23926,1.); +#23926 = DIRECTION('',(0.,1.)); +#23927 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23928 = PCURVE('',#20767,#23929); +#23929 = DEFINITIONAL_REPRESENTATION('',(#23930),#23934); +#23930 = LINE('',#23931,#23932); +#23931 = CARTESIAN_POINT('',(35.000000000021,-2.148381697179E-26)); +#23932 = VECTOR('',#23933,1.); +#23933 = DIRECTION('',(1.599442196757E-31,1.)); +#23934 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23935 = ADVANCED_FACE('',(#23936),#23950,.F.); +#23936 = FACE_BOUND('',#23937,.T.); +#23937 = EDGE_LOOP('',(#23938,#23973,#23996,#24024)); +#23938 = ORIENTED_EDGE('',*,*,#23939,.T.); +#23939 = EDGE_CURVE('',#23940,#23942,#23944,.T.); +#23940 = VERTEX_POINT('',#23941); +#23941 = CARTESIAN_POINT('',(-43.44310988842,4.599999999996,24.5)); +#23942 = VERTEX_POINT('',#23943); +#23943 = CARTESIAN_POINT('',(-45.32310988843,4.599999999996,19.8)); +#23944 = SURFACE_CURVE('',#23945,(#23949,#23961),.PCURVE_S1.); +#23945 = LINE('',#23946,#23947); +#23946 = CARTESIAN_POINT('',(-43.44310988842,4.599999999996,24.5)); +#23947 = VECTOR('',#23948,1.); +#23948 = DIRECTION('',(-0.371390676355,-1.707479535198E-15, + -0.928476690885)); +#23949 = PCURVE('',#23950,#23955); +#23950 = PLANE('',#23951); +#23951 = AXIS2_PLACEMENT_3D('',#23952,#23953,#23954); +#23952 = CARTESIAN_POINT('',(-45.32310988843,4.599999999996,19.8)); +#23953 = DIRECTION('',(-0.928476690885,-2.312337097562E-15, + 0.371390676355)); +#23954 = DIRECTION('',(0.371390676355,1.707479535198E-15,0.928476690885) + ); +#23955 = DEFINITIONAL_REPRESENTATION('',(#23956),#23960); +#23956 = LINE('',#23957,#23958); +#23957 = CARTESIAN_POINT('',(5.062054918708,-5.138592570603E-16)); +#23958 = VECTOR('',#23959,1.); +#23959 = DIRECTION('',(-1.,-9.621226973385E-30)); +#23960 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23961 = PCURVE('',#23962,#23967); +#23962 = PLANE('',#23963); +#23963 = AXIS2_PLACEMENT_3D('',#23964,#23965,#23966); +#23964 = CARTESIAN_POINT('',(-59.3,4.599999999996,19.8)); +#23965 = DIRECTION('',(-2.791344548659E-15,1.,-8.553453836232E-16)); +#23966 = DIRECTION('',(1.,2.791344548659E-15,-3.489751902455E-29)); +#23967 = DEFINITIONAL_REPRESENTATION('',(#23968),#23972); +#23968 = LINE('',#23969,#23970); +#23969 = CARTESIAN_POINT('',(15.856890111574,-4.7)); +#23970 = VECTOR('',#23971,1.); +#23971 = DIRECTION('',(-0.371390676355,0.928476690885)); +#23972 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23973 = ORIENTED_EDGE('',*,*,#23974,.T.); +#23974 = EDGE_CURVE('',#23942,#23975,#23977,.T.); +#23975 = VERTEX_POINT('',#23976); +#23976 = CARTESIAN_POINT('',(-45.32310988843,13.999999999996,19.8)); +#23977 = SURFACE_CURVE('',#23978,(#23982,#23989),.PCURVE_S1.); +#23978 = LINE('',#23979,#23980); +#23979 = CARTESIAN_POINT('',(-45.32310988843,9.875000000003,19.8)); +#23980 = VECTOR('',#23981,1.); +#23981 = DIRECTION('',(-2.832601425455E-15,1.,-8.553453836232E-16)); +#23982 = PCURVE('',#23950,#23983); +#23983 = DEFINITIONAL_REPRESENTATION('',(#23984),#23988); +#23984 = LINE('',#23985,#23986); +#23985 = CARTESIAN_POINT('',(4.667513439536E-15,5.275000000007)); +#23986 = VECTOR('',#23987,1.); +#23987 = DIRECTION('',(-1.386904753947E-16,1.)); +#23988 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23989 = PCURVE('',#21855,#23990); +#23990 = DEFINITIONAL_REPRESENTATION('',(#23991),#23995); +#23991 = LINE('',#23992,#23993); +#23992 = CARTESIAN_POINT('',(1.326890111548,-25.02500000001)); +#23993 = VECTOR('',#23994,1.); +#23994 = DIRECTION('',(-4.1027581133E-14,-1.)); +#23995 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#23996 = ORIENTED_EDGE('',*,*,#23997,.T.); +#23997 = EDGE_CURVE('',#23975,#23998,#24000,.T.); +#23998 = VERTEX_POINT('',#23999); +#23999 = CARTESIAN_POINT('',(-43.44310988842,13.999999999996,24.5)); +#24000 = SURFACE_CURVE('',#24001,(#24005,#24012),.PCURVE_S1.); +#24001 = LINE('',#24002,#24003); +#24002 = CARTESIAN_POINT('',(-43.44310988842,13.999999999996,24.5)); +#24003 = VECTOR('',#24004,1.); +#24004 = DIRECTION('',(0.371390676355,1.707479535198E-15,0.928476690885) + ); +#24005 = PCURVE('',#23950,#24006); +#24006 = DEFINITIONAL_REPRESENTATION('',(#24007),#24011); +#24007 = LINE('',#24008,#24009); +#24008 = CARTESIAN_POINT('',(5.062054918708,9.4)); +#24009 = VECTOR('',#24010,1.); +#24010 = DIRECTION('',(1.,9.621226973385E-30)); +#24011 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24012 = PCURVE('',#24013,#24018); +#24013 = PLANE('',#24014); +#24014 = AXIS2_PLACEMENT_3D('',#24015,#24016,#24017); +#24015 = CARTESIAN_POINT('',(-49.,13.999999999996,22.15)); +#24016 = DIRECTION('',(2.796791315202E-15,-1.,7.658201079909E-16)); +#24017 = DIRECTION('',(-3.608975738512E-29,-7.658201079909E-16,-1.)); +#24018 = DEFINITIONAL_REPRESENTATION('',(#24019),#24023); +#24019 = LINE('',#24020,#24021); +#24020 = CARTESIAN_POINT('',(-2.35,5.556890111577)); +#24021 = VECTOR('',#24022,1.); +#24022 = DIRECTION('',(-0.928476690885,0.371390676355)); +#24023 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24024 = ORIENTED_EDGE('',*,*,#24025,.F.); +#24025 = EDGE_CURVE('',#23940,#23998,#24026,.T.); +#24026 = SURFACE_CURVE('',#24027,(#24031,#24038),.PCURVE_S1.); +#24027 = LINE('',#24028,#24029); +#24028 = CARTESIAN_POINT('',(-43.44310988842,4.599999999996,24.5)); +#24029 = VECTOR('',#24030,1.); +#24030 = DIRECTION('',(-2.796791315202E-15,1.,-7.658201079909E-16)); +#24031 = PCURVE('',#23950,#24032); +#24032 = DEFINITIONAL_REPRESENTATION('',(#24033),#24037); +#24033 = LINE('',#24034,#24035); +#24034 = CARTESIAN_POINT('',(5.062054918708,-5.138592570603E-16)); +#24035 = VECTOR('',#24036,1.); +#24036 = DIRECTION('',(-4.22688026579E-17,1.)); +#24037 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24038 = PCURVE('',#24039,#24044); +#24039 = PLANE('',#24040); +#24040 = AXIS2_PLACEMENT_3D('',#24041,#24042,#24043); +#24041 = CARTESIAN_POINT('',(-43.44310988842,4.599999999996,24.5)); +#24042 = DIRECTION('',(-2.638265935754E-30,-7.658201079909E-16,-1.)); +#24043 = DIRECTION('',(-1.,-2.796664588987E-15,4.780007913306E-30)); +#24044 = DEFINITIONAL_REPRESENTATION('',(#24045),#24049); +#24045 = LINE('',#24046,#24047); +#24046 = CARTESIAN_POINT('',(0.,0.)); +#24047 = VECTOR('',#24048,1.); +#24048 = DIRECTION('',(1.26726215103E-19,1.)); +#24049 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24050 = ADVANCED_FACE('',(#24051),#24065,.F.); +#24051 = FACE_BOUND('',#24052,.T.); +#24052 = EDGE_LOOP('',(#24053,#24083,#24106,#24129)); +#24053 = ORIENTED_EDGE('',*,*,#24054,.F.); +#24054 = EDGE_CURVE('',#24055,#24057,#24059,.T.); +#24055 = VERTEX_POINT('',#24056); +#24056 = CARTESIAN_POINT('',(-54.55689011158,4.599999999996,24.5)); +#24057 = VERTEX_POINT('',#24058); +#24058 = CARTESIAN_POINT('',(-52.67689011156,4.599999999996,19.8)); +#24059 = SURFACE_CURVE('',#24060,(#24064,#24076),.PCURVE_S1.); +#24060 = LINE('',#24061,#24062); +#24061 = CARTESIAN_POINT('',(-54.55689011158,4.599999999996,24.5)); +#24062 = VECTOR('',#24063,1.); +#24063 = DIRECTION('',(0.371390676357,3.698307712901E-16,-0.928476690884 + )); +#24064 = PCURVE('',#24065,#24070); +#24065 = PLANE('',#24066); +#24066 = AXIS2_PLACEMENT_3D('',#24067,#24068,#24069); +#24067 = CARTESIAN_POINT('',(-54.55689011158,4.599999999996,24.5)); +#24068 = DIRECTION('',(0.928476690884,2.881173993307E-15,0.371390676357) + ); +#24069 = DIRECTION('',(0.371390676357,3.698307712901E-16,-0.928476690884 + )); +#24070 = DEFINITIONAL_REPRESENTATION('',(#24071),#24075); +#24071 = LINE('',#24072,#24073); +#24072 = CARTESIAN_POINT('',(0.,0.)); +#24073 = VECTOR('',#24074,1.); +#24074 = DIRECTION('',(1.,-2.711525997691E-32)); +#24075 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24076 = PCURVE('',#23962,#24077); +#24077 = DEFINITIONAL_REPRESENTATION('',(#24078),#24082); +#24078 = LINE('',#24079,#24080); +#24079 = CARTESIAN_POINT('',(4.74310988842,-4.7)); +#24080 = VECTOR('',#24081,1.); +#24081 = DIRECTION('',(0.371390676357,0.928476690884)); +#24082 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24083 = ORIENTED_EDGE('',*,*,#24084,.T.); +#24084 = EDGE_CURVE('',#24055,#24085,#24087,.T.); +#24085 = VERTEX_POINT('',#24086); +#24086 = CARTESIAN_POINT('',(-54.55689011158,13.999999999996,24.5)); +#24087 = SURFACE_CURVE('',#24088,(#24092,#24099),.PCURVE_S1.); +#24088 = LINE('',#24089,#24090); +#24089 = CARTESIAN_POINT('',(-54.55689011158,4.599999999996,24.5)); +#24090 = VECTOR('',#24091,1.); +#24091 = DIRECTION('',(-2.796791315202E-15,1.,-7.658201079909E-16)); +#24092 = PCURVE('',#24065,#24093); +#24093 = DEFINITIONAL_REPRESENTATION('',(#24094),#24098); +#24094 = LINE('',#24095,#24096); +#24095 = CARTESIAN_POINT('',(0.,0.)); +#24096 = VECTOR('',#24097,1.); +#24097 = DIRECTION('',(4.217467278843E-17,1.)); +#24098 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24099 = PCURVE('',#24039,#24100); +#24100 = DEFINITIONAL_REPRESENTATION('',(#24101),#24105); +#24101 = LINE('',#24102,#24103); +#24102 = CARTESIAN_POINT('',(11.113780223153,-4.504295707283E-15)); +#24103 = VECTOR('',#24104,1.); +#24104 = DIRECTION('',(1.26726215103E-19,1.)); +#24105 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24106 = ORIENTED_EDGE('',*,*,#24107,.T.); +#24107 = EDGE_CURVE('',#24085,#24108,#24110,.T.); +#24108 = VERTEX_POINT('',#24109); +#24109 = CARTESIAN_POINT('',(-52.67689011156,13.999999999996,19.8)); +#24110 = SURFACE_CURVE('',#24111,(#24115,#24122),.PCURVE_S1.); +#24111 = LINE('',#24112,#24113); +#24112 = CARTESIAN_POINT('',(-54.55689011158,13.999999999996,24.5)); +#24113 = VECTOR('',#24114,1.); +#24114 = DIRECTION('',(0.371390676357,3.698307712901E-16,-0.928476690884 + )); +#24115 = PCURVE('',#24065,#24116); +#24116 = DEFINITIONAL_REPRESENTATION('',(#24117),#24121); +#24117 = LINE('',#24118,#24119); +#24118 = CARTESIAN_POINT('',(-5.682184383627E-15,9.4)); +#24119 = VECTOR('',#24120,1.); +#24120 = DIRECTION('',(1.,-2.711525997691E-32)); +#24121 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24122 = PCURVE('',#24013,#24123); +#24123 = DEFINITIONAL_REPRESENTATION('',(#24124),#24128); +#24124 = LINE('',#24125,#24126); +#24125 = CARTESIAN_POINT('',(-2.35,-5.556890111577)); +#24126 = VECTOR('',#24127,1.); +#24127 = DIRECTION('',(0.928476690884,0.371390676357)); +#24128 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24129 = ORIENTED_EDGE('',*,*,#24130,.T.); +#24130 = EDGE_CURVE('',#24108,#24057,#24131,.T.); +#24131 = SURFACE_CURVE('',#24132,(#24136,#24143),.PCURVE_S1.); +#24132 = LINE('',#24133,#24134); +#24133 = CARTESIAN_POINT('',(-52.67689011156,9.875000000003,19.8)); +#24134 = VECTOR('',#24135,1.); +#24135 = DIRECTION('',(2.760981204948E-15,-1.,8.553453836232E-16)); +#24136 = PCURVE('',#24065,#24137); +#24137 = DEFINITIONAL_REPRESENTATION('',(#24138),#24142); +#24138 = LINE('',#24139,#24140); +#24139 = CARTESIAN_POINT('',(5.062054918712,5.275000000007)); +#24140 = VECTOR('',#24141,1.); +#24141 = DIRECTION('',(-1.385963455254E-16,-1.)); +#24142 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24143 = PCURVE('',#21855,#24144); +#24144 = DEFINITIONAL_REPRESENTATION('',(#24145),#24149); +#24145 = LINE('',#24146,#24147); +#24146 = CARTESIAN_POINT('',(-6.026890111586,-25.02500000001)); +#24147 = VECTOR('',#24148,1.); +#24148 = DIRECTION('',(4.09559609125E-14,1.)); +#24149 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24150 = ADVANCED_FACE('',(#24151),#24039,.F.); +#24151 = FACE_BOUND('',#24152,.T.); +#24152 = EDGE_LOOP('',(#24153,#24174,#24175,#24196)); +#24153 = ORIENTED_EDGE('',*,*,#24154,.F.); +#24154 = EDGE_CURVE('',#23940,#24055,#24155,.T.); +#24155 = SURFACE_CURVE('',#24156,(#24160,#24167),.PCURVE_S1.); +#24156 = LINE('',#24157,#24158); +#24157 = CARTESIAN_POINT('',(-43.44310988842,4.599999999996,24.5)); +#24158 = VECTOR('',#24159,1.); +#24159 = DIRECTION('',(-1.,-2.796664588987E-15,4.780007913306E-30)); +#24160 = PCURVE('',#24039,#24161); +#24161 = DEFINITIONAL_REPRESENTATION('',(#24162),#24166); +#24162 = LINE('',#24163,#24164); +#24163 = CARTESIAN_POINT('',(0.,0.)); +#24164 = VECTOR('',#24165,1.); +#24165 = DIRECTION('',(1.,-3.660626176365E-45)); +#24166 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24167 = PCURVE('',#23962,#24168); +#24168 = DEFINITIONAL_REPRESENTATION('',(#24169),#24173); +#24169 = LINE('',#24170,#24171); +#24170 = CARTESIAN_POINT('',(15.856890111574,-4.7)); +#24171 = VECTOR('',#24172,1.); +#24172 = DIRECTION('',(-1.,3.012206158318E-29)); +#24173 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24174 = ORIENTED_EDGE('',*,*,#24025,.T.); +#24175 = ORIENTED_EDGE('',*,*,#24176,.T.); +#24176 = EDGE_CURVE('',#23998,#24085,#24177,.T.); +#24177 = SURFACE_CURVE('',#24178,(#24182,#24189),.PCURVE_S1.); +#24178 = LINE('',#24179,#24180); +#24179 = CARTESIAN_POINT('',(-43.44310988842,13.999999999996,24.5)); +#24180 = VECTOR('',#24181,1.); +#24181 = DIRECTION('',(-1.,-2.796664588987E-15,4.780007913306E-30)); +#24182 = PCURVE('',#24039,#24183); +#24183 = DEFINITIONAL_REPRESENTATION('',(#24184),#24188); +#24184 = LINE('',#24185,#24186); +#24185 = CARTESIAN_POINT('',(5.477048280619E-15,9.4)); +#24186 = VECTOR('',#24187,1.); +#24187 = DIRECTION('',(1.,-3.660626176365E-45)); +#24188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24189 = PCURVE('',#24013,#24190); +#24190 = DEFINITIONAL_REPRESENTATION('',(#24191),#24195); +#24191 = LINE('',#24192,#24193); +#24192 = CARTESIAN_POINT('',(-2.35,5.556890111577)); +#24193 = VECTOR('',#24194,1.); +#24194 = DIRECTION('',(3.345149144937E-29,-1.)); +#24195 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24196 = ORIENTED_EDGE('',*,*,#24084,.F.); +#24197 = ADVANCED_FACE('',(#24198),#24013,.F.); +#24198 = FACE_BOUND('',#24199,.T.); +#24199 = EDGE_LOOP('',(#24200,#24201,#24202,#24223)); +#24200 = ORIENTED_EDGE('',*,*,#24176,.F.); +#24201 = ORIENTED_EDGE('',*,*,#23997,.F.); +#24202 = ORIENTED_EDGE('',*,*,#24203,.T.); +#24203 = EDGE_CURVE('',#23975,#24108,#24204,.T.); +#24204 = SURFACE_CURVE('',#24205,(#24209,#24216),.PCURVE_S1.); +#24205 = LINE('',#24206,#24207); +#24206 = CARTESIAN_POINT('',(-47.82499999999,13.999999999996,19.8)); +#24207 = VECTOR('',#24208,1.); +#24208 = DIRECTION('',(-1.,-2.796791315202E-15,3.490217789117E-29)); +#24209 = PCURVE('',#24013,#24210); +#24210 = DEFINITIONAL_REPRESENTATION('',(#24211),#24215); +#24211 = LINE('',#24212,#24213); +#24212 = CARTESIAN_POINT('',(2.35,1.175000000012)); +#24213 = VECTOR('',#24214,1.); +#24214 = DIRECTION('',(3.329418520983E-30,-1.)); +#24215 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24216 = PCURVE('',#21855,#24217); +#24217 = DEFINITIONAL_REPRESENTATION('',(#24218),#24222); +#24218 = LINE('',#24219,#24220); +#24219 = CARTESIAN_POINT('',(-1.175000000013,-29.15)); +#24220 = VECTOR('',#24221,1.); +#24221 = DIRECTION('',(-1.,4.099177102275E-14)); +#24222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24223 = ORIENTED_EDGE('',*,*,#24107,.F.); +#24224 = ADVANCED_FACE('',(#24225),#23770,.F.); +#24225 = FACE_BOUND('',#24226,.T.); +#24226 = EDGE_LOOP('',(#24227,#24250,#24273,#24294)); +#24227 = ORIENTED_EDGE('',*,*,#24228,.F.); +#24228 = EDGE_CURVE('',#24229,#23727,#24231,.T.); +#24229 = VERTEX_POINT('',#24230); +#24230 = CARTESIAN_POINT('',(-38.7,4.599999999996,18.3)); +#24231 = SURFACE_CURVE('',#24232,(#24236,#24243),.PCURVE_S1.); +#24232 = LINE('',#24233,#24234); +#24233 = CARTESIAN_POINT('',(-38.7,3.449999999996,18.3)); +#24234 = VECTOR('',#24235,1.); +#24235 = DIRECTION('',(3.86269226848E-14,-1.,9.705420841629E-16)); +#24236 = PCURVE('',#23770,#24237); +#24237 = DEFINITIONAL_REPRESENTATION('',(#24238),#24242); +#24238 = LINE('',#24239,#24240); +#24239 = CARTESIAN_POINT('',(1.15,1.5)); +#24240 = VECTOR('',#24241,1.); +#24241 = DIRECTION('',(1.,-1.151967005397E-16)); +#24242 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24243 = PCURVE('',#23742,#24244); +#24244 = DEFINITIONAL_REPRESENTATION('',(#24245),#24249); +#24245 = LINE('',#24246,#24247); +#24246 = CARTESIAN_POINT('',(1.85,5.749999999992)); +#24247 = VECTOR('',#24248,1.); +#24248 = DIRECTION('',(-7.682190239235E-14,-1.)); +#24249 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24250 = ORIENTED_EDGE('',*,*,#24251,.T.); +#24251 = EDGE_CURVE('',#24229,#24252,#24254,.T.); +#24252 = VERTEX_POINT('',#24253); +#24253 = CARTESIAN_POINT('',(-38.7,4.599999999996,4.5)); +#24254 = SURFACE_CURVE('',#24255,(#24259,#24266),.PCURVE_S1.); +#24255 = LINE('',#24256,#24257); +#24256 = CARTESIAN_POINT('',(-38.7,4.599999999996,19.8)); +#24257 = VECTOR('',#24258,1.); +#24258 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24259 = PCURVE('',#23770,#24260); +#24260 = DEFINITIONAL_REPRESENTATION('',(#24261),#24265); +#24261 = LINE('',#24262,#24263); +#24262 = CARTESIAN_POINT('',(0.,-0.)); +#24263 = VECTOR('',#24264,1.); +#24264 = DIRECTION('',(0.,1.)); +#24265 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24266 = PCURVE('',#23962,#24267); +#24267 = DEFINITIONAL_REPRESENTATION('',(#24268),#24272); +#24268 = LINE('',#24269,#24270); +#24269 = CARTESIAN_POINT('',(20.6,-7.191791939538E-28)); +#24270 = VECTOR('',#24271,1.); +#24271 = DIRECTION('',(-1.599442196756E-31,1.)); +#24272 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24273 = ORIENTED_EDGE('',*,*,#24274,.T.); +#24274 = EDGE_CURVE('',#24252,#23755,#24275,.T.); +#24275 = SURFACE_CURVE('',#24276,(#24280,#24287),.PCURVE_S1.); +#24276 = LINE('',#24277,#24278); +#24277 = CARTESIAN_POINT('',(-38.7,4.599999999996,4.5)); +#24278 = VECTOR('',#24279,1.); +#24279 = DIRECTION('',(3.86269226848E-14,-1.,8.553453836232E-16)); +#24280 = PCURVE('',#23770,#24281); +#24281 = DEFINITIONAL_REPRESENTATION('',(#24282),#24286); +#24282 = LINE('',#24283,#24284); +#24283 = CARTESIAN_POINT('',(-2.428643333033E-15,15.3)); +#24284 = VECTOR('',#24285,1.); +#24285 = DIRECTION('',(1.,0.)); +#24286 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24287 = PCURVE('',#21609,#24288); +#24288 = DEFINITIONAL_REPRESENTATION('',(#24289),#24293); +#24289 = LINE('',#24290,#24291); +#24290 = CARTESIAN_POINT('',(-7.949999999978,19.750000000007)); +#24291 = VECTOR('',#24292,1.); +#24292 = DIRECTION('',(-7.682190239235E-14,-1.)); +#24293 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24294 = ORIENTED_EDGE('',*,*,#23754,.F.); +#24295 = ADVANCED_FACE('',(#24296),#23962,.F.); +#24296 = FACE_BOUND('',#24297,.T.); +#24297 = EDGE_LOOP('',(#24298,#24321,#24322,#24323,#24324,#24347,#24375, + #24403,#24431,#24452,#24453,#24476)); +#24298 = ORIENTED_EDGE('',*,*,#24299,.T.); +#24299 = EDGE_CURVE('',#24300,#23942,#24302,.T.); +#24300 = VERTEX_POINT('',#24301); +#24301 = CARTESIAN_POINT('',(-35.,4.599999999996,19.8)); +#24302 = SURFACE_CURVE('',#24303,(#24307,#24314),.PCURVE_S1.); +#24303 = LINE('',#24304,#24305); +#24304 = CARTESIAN_POINT('',(-52.97499999998,4.599999999999,19.8)); +#24305 = VECTOR('',#24306,1.); +#24306 = DIRECTION('',(-1.,-4.180762244171E-13,3.901095239086E-28)); +#24307 = PCURVE('',#23962,#24308); +#24308 = DEFINITIONAL_REPRESENTATION('',(#24309),#24313); +#24309 = LINE('',#24310,#24311); +#24310 = CARTESIAN_POINT('',(6.325000000013,-2.208205516588E-28)); +#24311 = VECTOR('',#24312,1.); +#24312 = DIRECTION('',(-1.,-4.203895392974E-43)); +#24313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24314 = PCURVE('',#21855,#24315); +#24315 = DEFINITIONAL_REPRESENTATION('',(#24316),#24320); +#24316 = LINE('',#24317,#24318); +#24317 = CARTESIAN_POINT('',(-6.325000000009,-19.75)); +#24318 = VECTOR('',#24319,1.); +#24319 = DIRECTION('',(-1.,4.562712041247E-13)); +#24320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24321 = ORIENTED_EDGE('',*,*,#23939,.F.); +#24322 = ORIENTED_EDGE('',*,*,#24154,.T.); +#24323 = ORIENTED_EDGE('',*,*,#24054,.T.); +#24324 = ORIENTED_EDGE('',*,*,#24325,.T.); +#24325 = EDGE_CURVE('',#24057,#24326,#24328,.T.); +#24326 = VERTEX_POINT('',#24327); +#24327 = CARTESIAN_POINT('',(-63.,4.599999999995,19.8)); +#24328 = SURFACE_CURVE('',#24329,(#24333,#24340),.PCURVE_S1.); +#24329 = LINE('',#24330,#24331); +#24330 = CARTESIAN_POINT('',(-52.97499999998,4.599999999999,19.8)); +#24331 = VECTOR('',#24332,1.); +#24332 = DIRECTION('',(-1.,-4.180762244171E-13,3.901095239086E-28)); +#24333 = PCURVE('',#23962,#24334); +#24334 = DEFINITIONAL_REPRESENTATION('',(#24335),#24339); +#24335 = LINE('',#24336,#24337); +#24336 = CARTESIAN_POINT('',(6.325000000013,-2.208205516588E-28)); +#24337 = VECTOR('',#24338,1.); +#24338 = DIRECTION('',(-1.,-4.203895392974E-43)); +#24339 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24340 = PCURVE('',#21855,#24341); +#24341 = DEFINITIONAL_REPRESENTATION('',(#24342),#24346); +#24342 = LINE('',#24343,#24344); +#24343 = CARTESIAN_POINT('',(-6.325000000009,-19.75)); +#24344 = VECTOR('',#24345,1.); +#24345 = DIRECTION('',(-1.,4.562712041247E-13)); +#24346 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24347 = ORIENTED_EDGE('',*,*,#24348,.T.); +#24348 = EDGE_CURVE('',#24326,#24349,#24351,.T.); +#24349 = VERTEX_POINT('',#24350); +#24350 = CARTESIAN_POINT('',(-63.,4.599999999995,18.3)); +#24351 = SURFACE_CURVE('',#24352,(#24356,#24363),.PCURVE_S1.); +#24352 = LINE('',#24353,#24354); +#24353 = CARTESIAN_POINT('',(-63.,4.599999999995,19.8)); +#24354 = VECTOR('',#24355,1.); +#24355 = DIRECTION('',(-2.826939553641E-29,-9.705420841629E-16,-1.)); +#24356 = PCURVE('',#23962,#24357); +#24357 = DEFINITIONAL_REPRESENTATION('',(#24358),#24362); +#24358 = LINE('',#24359,#24360); +#24359 = CARTESIAN_POINT('',(-3.7,1.293167885894E-28)); +#24360 = VECTOR('',#24361,1.); +#24361 = DIRECTION('',(3.919006132273E-30,1.)); +#24362 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24363 = PCURVE('',#24364,#24369); +#24364 = PLANE('',#24365); +#24365 = AXIS2_PLACEMENT_3D('',#24366,#24367,#24368); +#24366 = CARTESIAN_POINT('',(-63.,-4.599999999995,19.8)); +#24367 = DIRECTION('',(-1.,3.722956838179E-14,7.145479213967E-31)); +#24368 = DIRECTION('',(3.722956838179E-14,1.,-8.553453836232E-16)); +#24369 = DEFINITIONAL_REPRESENTATION('',(#24370),#24374); +#24370 = LINE('',#24371,#24372); +#24371 = CARTESIAN_POINT('',(9.199999999989,-7.869177529324E-15)); +#24372 = VECTOR('',#24373,1.); +#24373 = DIRECTION('',(-1.151967005397E-16,1.)); +#24374 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24375 = ORIENTED_EDGE('',*,*,#24376,.F.); +#24376 = EDGE_CURVE('',#24377,#24349,#24379,.T.); +#24377 = VERTEX_POINT('',#24378); +#24378 = CARTESIAN_POINT('',(-59.3,4.599999999996,18.3)); +#24379 = SURFACE_CURVE('',#24380,(#24384,#24391),.PCURVE_S1.); +#24380 = LINE('',#24381,#24382); +#24381 = CARTESIAN_POINT('',(-59.3,4.599999999996,18.3)); +#24382 = VECTOR('',#24383,1.); +#24383 = DIRECTION('',(-1.,-4.180762244171E-13,3.901095239086E-28)); +#24384 = PCURVE('',#23962,#24385); +#24385 = DEFINITIONAL_REPRESENTATION('',(#24386),#24390); +#24386 = LINE('',#24387,#24388); +#24387 = CARTESIAN_POINT('',(1.594310982964E-29,1.5)); +#24388 = VECTOR('',#24389,1.); +#24389 = DIRECTION('',(-1.,-4.203895392974E-43)); +#24390 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24391 = PCURVE('',#24392,#24397); +#24392 = PLANE('',#24393); +#24393 = AXIS2_PLACEMENT_3D('',#24394,#24395,#24396); +#24394 = CARTESIAN_POINT('',(-61.15,-2.299999999996,18.3)); +#24395 = DIRECTION('',(-2.826996393094E-29,-7.401486830834E-16,-1.)); +#24396 = DIRECTION('',(-1.,3.819497970755E-14,2.24207754292E-44)); +#24397 = DEFINITIONAL_REPRESENTATION('',(#24398),#24402); +#24398 = LINE('',#24399,#24400); +#24399 = CARTESIAN_POINT('',(-1.85,6.899999999992)); +#24400 = VECTOR('',#24401,1.); +#24401 = DIRECTION('',(1.,-4.562712041247E-13)); +#24402 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24403 = ORIENTED_EDGE('',*,*,#24404,.T.); +#24404 = EDGE_CURVE('',#24377,#24405,#24407,.T.); +#24405 = VERTEX_POINT('',#24406); +#24406 = CARTESIAN_POINT('',(-59.3,4.599999999996,4.5)); +#24407 = SURFACE_CURVE('',#24408,(#24412,#24419),.PCURVE_S1.); +#24408 = LINE('',#24409,#24410); +#24409 = CARTESIAN_POINT('',(-59.3,4.599999999996,19.8)); +#24410 = VECTOR('',#24411,1.); +#24411 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24412 = PCURVE('',#23962,#24413); +#24413 = DEFINITIONAL_REPRESENTATION('',(#24414),#24418); +#24414 = LINE('',#24415,#24416); +#24415 = CARTESIAN_POINT('',(0.,0.)); +#24416 = VECTOR('',#24417,1.); +#24417 = DIRECTION('',(-1.599442196756E-31,1.)); +#24418 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24419 = PCURVE('',#24420,#24425); +#24420 = PLANE('',#24421); +#24421 = AXIS2_PLACEMENT_3D('',#24422,#24423,#24424); +#24422 = CARTESIAN_POINT('',(-59.3,4.602202957936E-12,19.8)); +#24423 = DIRECTION('',(1.,-4.68836816394E-14,7.431841087084E-30)); +#24424 = DIRECTION('',(-4.68836816394E-14,-1.,8.553453836232E-16)); +#24425 = DEFINITIONAL_REPRESENTATION('',(#24426),#24430); +#24426 = LINE('',#24427,#24428); +#24427 = CARTESIAN_POINT('',(-4.599999999992,-3.934588764659E-15)); +#24428 = VECTOR('',#24429,1.); +#24429 = DIRECTION('',(0.,1.)); +#24430 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24431 = ORIENTED_EDGE('',*,*,#24432,.T.); +#24432 = EDGE_CURVE('',#24405,#24252,#24433,.T.); +#24433 = SURFACE_CURVE('',#24434,(#24438,#24445),.PCURVE_S1.); +#24434 = LINE('',#24435,#24436); +#24435 = CARTESIAN_POINT('',(-59.3,4.599999999996,4.5)); +#24436 = VECTOR('',#24437,1.); +#24437 = DIRECTION('',(1.,2.791344548659E-15,-3.489751902455E-29)); +#24438 = PCURVE('',#23962,#24439); +#24439 = DEFINITIONAL_REPRESENTATION('',(#24440),#24444); +#24440 = LINE('',#24441,#24442); +#24441 = CARTESIAN_POINT('',(-1.211548953225E-29,15.3)); +#24442 = VECTOR('',#24443,1.); +#24443 = DIRECTION('',(1.,0.)); +#24444 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24445 = PCURVE('',#21609,#24446); +#24446 = DEFINITIONAL_REPRESENTATION('',(#24447),#24451); +#24447 = LINE('',#24448,#24449); +#24448 = CARTESIAN_POINT('',(12.650000000022,19.750000000006)); +#24449 = VECTOR('',#24450,1.); +#24450 = DIRECTION('',(-1.,4.098632425621E-14)); +#24451 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24452 = ORIENTED_EDGE('',*,*,#24251,.F.); +#24453 = ORIENTED_EDGE('',*,*,#24454,.F.); +#24454 = EDGE_CURVE('',#24455,#24229,#24457,.T.); +#24455 = VERTEX_POINT('',#24456); +#24456 = CARTESIAN_POINT('',(-35.,4.599999999996,18.3)); +#24457 = SURFACE_CURVE('',#24458,(#24462,#24469),.PCURVE_S1.); +#24458 = LINE('',#24459,#24460); +#24459 = CARTESIAN_POINT('',(-38.7,4.599999999996,18.3)); +#24460 = VECTOR('',#24461,1.); +#24461 = DIRECTION('',(-1.,-3.910009465996E-14,6.595404081738E-29)); +#24462 = PCURVE('',#23962,#24463); +#24463 = DEFINITIONAL_REPRESENTATION('',(#24464),#24468); +#24464 = LINE('',#24465,#24466); +#24465 = CARTESIAN_POINT('',(20.6,1.5)); +#24466 = VECTOR('',#24467,1.); +#24467 = DIRECTION('',(-1.,-5.044674471569E-44)); +#24468 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24469 = PCURVE('',#23742,#24470); +#24470 = DEFINITIONAL_REPRESENTATION('',(#24471),#24475); +#24471 = LINE('',#24472,#24473); +#24472 = CARTESIAN_POINT('',(1.85,6.899999999992)); +#24473 = VECTOR('',#24474,1.); +#24474 = DIRECTION('',(1.,-7.729507436751E-14)); +#24475 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24476 = ORIENTED_EDGE('',*,*,#24477,.F.); +#24477 = EDGE_CURVE('',#24300,#24455,#24478,.T.); +#24478 = SURFACE_CURVE('',#24479,(#24483,#24490),.PCURVE_S1.); +#24479 = LINE('',#24480,#24481); +#24480 = CARTESIAN_POINT('',(-35.,4.599999999996,19.8)); +#24481 = VECTOR('',#24482,1.); +#24482 = DIRECTION('',(-2.826939553641E-29,-9.705420841629E-16,-1.)); +#24483 = PCURVE('',#23962,#24484); +#24484 = DEFINITIONAL_REPRESENTATION('',(#24485),#24489); +#24485 = LINE('',#24486,#24487); +#24486 = CARTESIAN_POINT('',(24.3,-8.477362832321E-28)); +#24487 = VECTOR('',#24488,1.); +#24488 = DIRECTION('',(3.919006132273E-30,1.)); +#24489 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24490 = PCURVE('',#24491,#24496); +#24491 = PLANE('',#24492); +#24492 = AXIS2_PLACEMENT_3D('',#24493,#24494,#24495); +#24493 = CARTESIAN_POINT('',(-35.,8.169300000794E-15,19.8)); +#24494 = DIRECTION('',(1.,-4.929720995381E-14,8.217301096059E-30)); +#24495 = DIRECTION('',(-4.929720995381E-14,-1.,8.553453836232E-16)); +#24496 = DEFINITIONAL_REPRESENTATION('',(#24497),#24501); +#24497 = LINE('',#24498,#24499); +#24498 = CARTESIAN_POINT('',(-4.599999999996,-3.934588764663E-15)); +#24499 = VECTOR('',#24500,1.); +#24500 = DIRECTION('',(1.151967005397E-16,1.)); +#24501 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24502 = ADVANCED_FACE('',(#24503,#24552),#20767,.F.); +#24503 = FACE_BOUND('',#24504,.T.); +#24504 = EDGE_LOOP('',(#24505,#24528,#24549,#24550,#24551)); +#24505 = ORIENTED_EDGE('',*,*,#24506,.F.); +#24506 = EDGE_CURVE('',#24507,#23893,#24509,.T.); +#24507 = VERTEX_POINT('',#24508); +#24508 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,19.8)); +#24509 = SURFACE_CURVE('',#24510,(#24514,#24521),.PCURVE_S1.); +#24510 = LINE('',#24511,#24512); +#24511 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,19.8)); +#24512 = VECTOR('',#24513,1.); +#24513 = DIRECTION('',(-1.,7.556212847502E-13,-6.138072223278E-28)); +#24514 = PCURVE('',#20767,#24515); +#24515 = DEFINITIONAL_REPRESENTATION('',(#24516),#24520); +#24516 = LINE('',#24517,#24518); +#24517 = CARTESIAN_POINT('',(0.,0.)); +#24518 = VECTOR('',#24519,1.); +#24519 = DIRECTION('',(1.,0.)); +#24520 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24521 = PCURVE('',#21855,#24522); +#24522 = DEFINITIONAL_REPRESENTATION('',(#24523),#24527); +#24523 = LINE('',#24524,#24525); +#24524 = CARTESIAN_POINT('',(23.649999999998,-45.45)); +#24525 = VECTOR('',#24526,1.); +#24526 = DIRECTION('',(-1.,-7.174263050427E-13)); +#24527 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24528 = ORIENTED_EDGE('',*,*,#24529,.T.); +#24529 = EDGE_CURVE('',#24507,#23462,#24530,.T.); +#24530 = SURFACE_CURVE('',#24531,(#24535,#24542),.PCURVE_S1.); +#24531 = LINE('',#24532,#24533); +#24532 = CARTESIAN_POINT('',(-22.99999999997,30.299999999997,19.8)); +#24533 = VECTOR('',#24534,1.); +#24534 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24535 = PCURVE('',#20767,#24536); +#24536 = DEFINITIONAL_REPRESENTATION('',(#24537),#24541); +#24537 = LINE('',#24538,#24539); +#24538 = CARTESIAN_POINT('',(0.,0.)); +#24539 = VECTOR('',#24540,1.); +#24540 = DIRECTION('',(1.599442196757E-31,1.)); +#24541 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24542 = PCURVE('',#20548,#24543); +#24543 = DEFINITIONAL_REPRESENTATION('',(#24544),#24548); +#24544 = LINE('',#24545,#24546); +#24545 = CARTESIAN_POINT('',(-30.29999999999,7.355901788263E-14)); +#24546 = VECTOR('',#24547,1.); +#24547 = DIRECTION('',(-9.860761315263E-31,1.)); +#24548 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24549 = ORIENTED_EDGE('',*,*,#23461,.T.); +#24550 = ORIENTED_EDGE('',*,*,#23832,.F.); +#24551 = ORIENTED_EDGE('',*,*,#23915,.F.); +#24552 = FACE_BOUND('',#24553,.T.); +#24553 = EDGE_LOOP('',(#24554)); +#24554 = ORIENTED_EDGE('',*,*,#20752,.T.); +#24555 = ADVANCED_FACE('',(#24556),#24571,.T.); +#24556 = FACE_BOUND('',#24557,.T.); +#24557 = EDGE_LOOP('',(#24558,#24598,#24627,#24656,#24733)); +#24558 = ORIENTED_EDGE('',*,*,#24559,.T.); +#24559 = EDGE_CURVE('',#24560,#24562,#24564,.T.); +#24560 = VERTEX_POINT('',#24561); +#24561 = CARTESIAN_POINT('',(-55.15603122477,-17.09740748936,8.5)); +#24562 = VERTEX_POINT('',#24563); +#24563 = CARTESIAN_POINT('',(-53.,-23.30000000002,8.5)); +#24564 = SURFACE_CURVE('',#24565,(#24570,#24582),.PCURVE_S1.); +#24565 = CIRCLE('',#24566,10.); +#24566 = AXIS2_PLACEMENT_3D('',#24567,#24568,#24569); +#24567 = CARTESIAN_POINT('',(-63.,-23.30000000002,8.5)); +#24568 = DIRECTION('',(-4.237541799507E-29,-1.110223024625E-15,-1.)); +#24569 = DIRECTION('',(0.886877334465,0.462004971415,-5.129285567563E-16 + )); +#24570 = PCURVE('',#24571,#24576); +#24571 = TOROIDAL_SURFACE('',#24572,10.,5.); +#24572 = AXIS2_PLACEMENT_3D('',#24573,#24574,#24575); +#24573 = CARTESIAN_POINT('',(-63.,-23.30000000002,13.5)); +#24574 = DIRECTION('',(-4.240494589641E-29,-1.110223024625E-15,-1.)); +#24575 = DIRECTION('',(-1.,3.819497970755E-14,2.24207754292E-44)); +#24576 = DEFINITIONAL_REPRESENTATION('',(#24577),#24581); +#24577 = LINE('',#24578,#24579); +#24578 = CARTESIAN_POINT('',(-3.621847233221,1.570796326795)); +#24579 = VECTOR('',#24580,1.); +#24580 = DIRECTION('',(1.,6.637378835319E-16)); +#24581 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24582 = PCURVE('',#24583,#24588); +#24583 = PLANE('',#24584); +#24584 = AXIS2_PLACEMENT_3D('',#24585,#24586,#24587); +#24585 = CARTESIAN_POINT('',(-40.49999999997,-16.90000000001,8.5)); +#24586 = DIRECTION('',(4.240494589641E-29,1.110223024625E-15,1.)); +#24587 = DIRECTION('',(1.,-3.819497970755E-14,-2.24207754292E-44)); +#24588 = DEFINITIONAL_REPRESENTATION('',(#24589),#24597); +#24589 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#24590,#24591,#24592,#24593 + ,#24594,#24595,#24596),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#24590 = CARTESIAN_POINT('',(-13.63122665537,-1.779950285864)); +#24591 = CARTESIAN_POINT('',(-5.629065816968,-17.14111631961)); +#24592 = CARTESIAN_POINT('',(-22.93330625314,-16.39060787396)); +#24593 = CARTESIAN_POINT('',(-40.23754668932,-15.64009942831)); +#24594 = CARTESIAN_POINT('',(-30.93546709154,-1.029441840217)); +#24595 = CARTESIAN_POINT('',(-21.63338749377,13.581215747883)); +#24596 = CARTESIAN_POINT('',(-13.63122665537,-1.779950285864)); +#24597 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24598 = ORIENTED_EDGE('',*,*,#24599,.T.); +#24599 = EDGE_CURVE('',#24562,#24600,#24602,.T.); +#24600 = VERTEX_POINT('',#24601); +#24601 = CARTESIAN_POINT('',(-58.,-23.30000000002,13.5)); +#24602 = SURFACE_CURVE('',#24603,(#24608,#24615),.PCURVE_S1.); +#24603 = CIRCLE('',#24604,5.); +#24604 = AXIS2_PLACEMENT_3D('',#24605,#24606,#24607); +#24605 = CARTESIAN_POINT('',(-53.,-23.30000000002,13.5)); +#24606 = DIRECTION('',(2.220776815295E-14,1.,-8.881784197001E-16)); +#24607 = DIRECTION('',(-3.392395671713E-29,-8.881784197001E-16,-1.)); +#24608 = PCURVE('',#24571,#24609); +#24609 = DEFINITIONAL_REPRESENTATION('',(#24610),#24614); +#24610 = LINE('',#24611,#24612); +#24611 = CARTESIAN_POINT('',(3.14159265359,1.570796326795)); +#24612 = VECTOR('',#24613,1.); +#24613 = DIRECTION('',(-2.544443745171E-15,1.)); +#24614 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24615 = PCURVE('',#24616,#24621); +#24616 = CYLINDRICAL_SURFACE('',#24617,5.); +#24617 = AXIS2_PLACEMENT_3D('',#24618,#24619,#24620); +#24618 = CARTESIAN_POINT('',(-53.,-23.60000000001,13.5)); +#24619 = DIRECTION('',(-2.228178302125E-14,-1.,1.110223024625E-15)); +#24620 = DIRECTION('',(-0.707106781187,1.497055364191E-14, + -0.707106781187)); +#24621 = DEFINITIONAL_REPRESENTATION('',(#24622),#24626); +#24622 = LINE('',#24623,#24624); +#24623 = CARTESIAN_POINT('',(0.785398163397,-0.299999999992)); +#24624 = VECTOR('',#24625,1.); +#24625 = DIRECTION('',(-1.,2.261727773485E-15)); +#24626 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24627 = ORIENTED_EDGE('',*,*,#24628,.T.); +#24628 = EDGE_CURVE('',#24600,#24629,#24631,.T.); +#24629 = VERTEX_POINT('',#24630); +#24630 = CARTESIAN_POINT('',(-61.52966235425,-18.52107677324,13.5)); +#24631 = SURFACE_CURVE('',#24632,(#24637,#24644),.PCURVE_S1.); +#24632 = CIRCLE('',#24633,5.); +#24633 = AXIS2_PLACEMENT_3D('',#24634,#24635,#24636); +#24634 = CARTESIAN_POINT('',(-63.,-23.30000000002,13.5)); +#24635 = DIRECTION('',(4.237541799507E-29,1.110223024625E-15,1.)); +#24636 = DIRECTION('',(0.886877334465,0.462004971415,-5.129285567563E-16 + )); +#24637 = PCURVE('',#24571,#24638); +#24638 = DEFINITIONAL_REPRESENTATION('',(#24639),#24643); +#24639 = LINE('',#24640,#24641); +#24640 = CARTESIAN_POINT('',(8.944523381138,3.14159265359)); +#24641 = VECTOR('',#24642,1.); +#24642 = DIRECTION('',(-1.,2.094239230839E-15)); +#24643 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24644 = PCURVE('',#24645,#24650); +#24645 = CYLINDRICAL_SURFACE('',#24646,5.); +#24646 = AXIS2_PLACEMENT_3D('',#24647,#24648,#24649); +#24647 = CARTESIAN_POINT('',(-63.,-23.30000000002,19.8)); +#24648 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24649 = DIRECTION('',(0.707106781187,0.707106781187,-6.048205210166E-16 + )); +#24650 = DEFINITIONAL_REPRESENTATION('',(#24651),#24655); +#24651 = LINE('',#24652,#24653); +#24652 = CARTESIAN_POINT('',(12.871514198126,6.3)); +#24653 = VECTOR('',#24654,1.); +#24654 = DIRECTION('',(-1.,0.)); +#24655 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24656 = ORIENTED_EDGE('',*,*,#24657,.T.); +#24657 = EDGE_CURVE('',#24629,#24658,#24660,.T.); +#24658 = VERTEX_POINT('',#24659); +#24659 = CARTESIAN_POINT('',(-58.11198325875,-18.34735292086, + 9.531425563737)); +#24660 = SURFACE_CURVE('',#24661,(#24670,#24699),.PCURVE_S1.); +#24661 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24662,#24663,#24664,#24665, + #24666,#24667,#24668,#24669),.UNSPECIFIED.,.F.,.F.,(4,2,2,4),( + -1.80953289085,-1.808667487311,-1.536099373537,-1.399847384662), + .UNSPECIFIED.); +#24662 = CARTESIAN_POINT('',(-61.52966235425,-18.52107677324,13.5)); +#24663 = CARTESIAN_POINT('',(-61.52782294596,-18.52164270642, + 13.497278344907)); +#24664 = CARTESIAN_POINT('',(-61.52598320975,-18.52220757799, + 13.494556688076)); +#24665 = CARTESIAN_POINT('',(-60.94459553198,-18.70034927815, + 12.634621231189)); +#24666 = CARTESIAN_POINT('',(-60.18561776626,-18.81762992713, + 11.553471842447)); +#24667 = CARTESIAN_POINT('',(-58.87876245473,-18.62070702436, + 10.169713345628)); +#24668 = CARTESIAN_POINT('',(-58.47695607637,-18.50168428374, + 9.812088506353)); +#24669 = CARTESIAN_POINT('',(-58.11198325875,-18.34735292086, + 9.531425563737)); +#24670 = PCURVE('',#24571,#24671); +#24671 = DEFINITIONAL_REPRESENTATION('',(#24672),#24698); +#24672 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24673,#24674,#24675,#24676, + #24677,#24678,#24679,#24680,#24681,#24682,#24683,#24684,#24685, + #24686,#24687,#24688,#24689,#24690,#24691,#24692,#24693,#24694, + #24695,#24696,#24697),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.80953289085,-1.790910822387, + -1.772288753924,-1.753666685461,-1.735044616998,-1.716422548535, + -1.697800480071,-1.679178411608,-1.660556343145,-1.641934274682, + -1.623312206219,-1.604690137756,-1.586068069293,-1.56744600083, + -1.548823932367,-1.530201863904,-1.511579795441,-1.492957726977, + -1.474335658514,-1.455713590051,-1.437091521588,-1.418469453125, + -1.399847384662),.QUASI_UNIFORM_KNOTS.); +#24673 = CARTESIAN_POINT('',(1.869276091153,3.14159265359)); +#24674 = CARTESIAN_POINT('',(1.877544558226,3.129897490546)); +#24675 = CARTESIAN_POINT('',(1.8943731739,3.106090373129)); +#24676 = CARTESIAN_POINT('',(1.920346715296,3.069217741913)); +#24677 = CARTESIAN_POINT('',(1.946911995379,3.031274238917)); +#24678 = CARTESIAN_POINT('',(1.973910718659,2.992341622015)); +#24679 = CARTESIAN_POINT('',(2.001176445188,2.952493751811)); +#24680 = CARTESIAN_POINT('',(2.028535413307,2.911797001496)); +#24681 = CARTESIAN_POINT('',(2.055810750789,2.870311242251)); +#24682 = CARTESIAN_POINT('',(2.082826093129,2.828090957627)); +#24683 = CARTESIAN_POINT('',(2.109409551272,2.785186136649)); +#24684 = CARTESIAN_POINT('',(2.135396958494,2.741644125454)); +#24685 = CARTESIAN_POINT('',(2.160636447587,2.697507347189)); +#24686 = CARTESIAN_POINT('',(2.184986063619,2.652825372619)); +#24687 = CARTESIAN_POINT('',(2.208334618958,2.607611896539)); +#24688 = CARTESIAN_POINT('',(2.230532651236,2.562005462601)); +#24689 = CARTESIAN_POINT('',(2.251655569992,2.515667745309)); +#24690 = CARTESIAN_POINT('',(2.270785037445,2.470550947747)); +#24691 = CARTESIAN_POINT('',(2.288001338105,2.426718415631)); +#24692 = CARTESIAN_POINT('',(2.303441348211,2.38407903125)); +#24693 = CARTESIAN_POINT('',(2.317225786852,2.342589333701)); +#24694 = CARTESIAN_POINT('',(2.329475697876,2.302198454374)); +#24695 = CARTESIAN_POINT('',(2.340306803125,2.262861846438)); +#24696 = CARTESIAN_POINT('',(2.346653618231,2.237313097577)); +#24697 = CARTESIAN_POINT('',(2.349626903915,2.224700660411)); +#24698 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24699 = PCURVE('',#24700,#24705); +#24700 = CYLINDRICAL_SURFACE('',#24701,5.); +#24701 = AXIS2_PLACEMENT_3D('',#24702,#24703,#24704); +#24702 = CARTESIAN_POINT('',(-60.0593247085,-13.74215354645,19.8)); +#24703 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24704 = DIRECTION('',(5.076540218662E-02,-0.998710605702, + 8.542425061624E-16)); +#24705 = DEFINITIONAL_REPRESENTATION('',(#24706),#24732); +#24706 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24707,#24708,#24709,#24710, + #24711,#24712,#24713,#24714,#24715,#24716,#24717,#24718,#24719, + #24720,#24721,#24722,#24723,#24724,#24725,#24726,#24727,#24728, + #24729,#24730,#24731),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.80953289085,-1.790910822387, + -1.772288753924,-1.753666685461,-1.735044616998,-1.716422548535, + -1.697800480071,-1.679178411608,-1.660556343145,-1.641934274682, + -1.623312206219,-1.604690137756,-1.586068069293,-1.56744600083, + -1.548823932367,-1.530201863904,-1.511579795441,-1.492957726977, + -1.474335658514,-1.455713590051,-1.437091521588,-1.418469453125, + -1.399847384662),.QUASI_UNIFORM_KNOTS.); +#24707 = CARTESIAN_POINT('',(0.349266996678,6.3)); +#24708 = CARTESIAN_POINT('',(0.340997096147,6.358472257591)); +#24709 = CARTESIAN_POINT('',(0.324171089878,6.477514219139)); +#24710 = CARTESIAN_POINT('',(0.298098183854,6.66164355055)); +#24711 = CARTESIAN_POINT('',(0.271216920264,6.850616698887)); +#24712 = CARTESIAN_POINT('',(0.243549967989,7.043699269531)); +#24713 = CARTESIAN_POINT('',(0.215116343472,7.240160038991)); +#24714 = CARTESIAN_POINT('',(0.185931349838,7.439266921725)); +#24715 = CARTESIAN_POINT('',(0.156006314845,7.640288109264)); +#24716 = CARTESIAN_POINT('',(0.125348454062,7.842491546889)); +#24717 = CARTESIAN_POINT('',(9.396051009336E-02,8.045145887823)); +#24718 = CARTESIAN_POINT('',(6.184127385425E-02,8.24751719976)); +#24719 = CARTESIAN_POINT('',(2.898295120307E-02,8.448881184571)); +#24720 = CARTESIAN_POINT('',(-4.619542846191E-03,8.648477592948)); +#24721 = CARTESIAN_POINT('',(-3.900360844941E-02,8.845680346127)); +#24722 = CARTESIAN_POINT('',(-7.410834920646E-02,9.039362634343)); +#24723 = CARTESIAN_POINT('',(-0.110261836153,9.230266401288)); +#24724 = CARTESIAN_POINT('',(-0.145941007794,9.410039544505)); +#24725 = CARTESIAN_POINT('',(-0.181062555183,9.578649832301)); +#24726 = CARTESIAN_POINT('',(-0.215678230734,9.736622421779)); +#24727 = CARTESIAN_POINT('',(-0.249799216097,9.884333117899)); +#24728 = CARTESIAN_POINT('',(-0.283443025332,10.022197745392)); +#24729 = CARTESIAN_POINT('',(-0.316621339719,10.150621402043)); +#24730 = CARTESIAN_POINT('',(-0.33843500056,10.23021518312)); +#24731 = CARTESIAN_POINT('',(-0.349266996678,10.268574436263)); +#24732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24733 = ORIENTED_EDGE('',*,*,#24734,.T.); +#24734 = EDGE_CURVE('',#24658,#24560,#24735,.T.); +#24735 = SURFACE_CURVE('',#24736,(#24747,#24776),.PCURVE_S1.); +#24736 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24737,#24738,#24739,#24740, + #24741,#24742,#24743,#24744,#24745,#24746),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.072156503551,-1.04598248422,-0.946418753147, + -0.848256540402,-0.750094327657),.UNSPECIFIED.); +#24737 = CARTESIAN_POINT('',(-58.11198325874,-18.34735292086, + 9.531425563735)); +#24738 = CARTESIAN_POINT('',(-58.04082429446,-18.31726284454, + 9.476704545222)); +#24739 = CARTESIAN_POINT('',(-57.9679894482,-18.28646410955, + 9.423620989079)); +#24740 = CARTESIAN_POINT('',(-57.61239793046,-18.13609969633, + 9.178405891423)); +#24741 = CARTESIAN_POINT('',(-57.31270007605,-18.00937031789, + 9.015206983342)); +#24742 = CARTESIAN_POINT('',(-56.74866248454,-17.77086299349, + 8.771545663279)); +#24743 = CARTESIAN_POINT('',(-56.43221650652,-17.63705155135, + 8.667639114369)); +#24744 = CARTESIAN_POINT('',(-55.78659338139,-17.3640452013, + 8.531827136925)); +#24745 = CARTESIAN_POINT('',(-55.45740226526,-17.22484438647,8.5)); +#24746 = CARTESIAN_POINT('',(-55.15603122477,-17.09740748936,8.5)); +#24747 = PCURVE('',#24571,#24748); +#24748 = DEFINITIONAL_REPRESENTATION('',(#24749),#24775); +#24749 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24750,#24751,#24752,#24753, + #24754,#24755,#24756,#24757,#24758,#24759,#24760,#24761,#24762, + #24763,#24764,#24765,#24766,#24767,#24768,#24769,#24770,#24771, + #24772,#24773,#24774),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(-1.072156503551,-1.057517313737, + -1.042878123924,-1.028238934111,-1.013599744297,-0.998960554484, + -0.984321364671,-0.969682174857,-0.955042985044,-0.94040379523, + -0.925764605417,-0.911125415604,-0.89648622579,-0.881847035977, + -0.867207846164,-0.85256865635,-0.837929466537,-0.823290276724, + -0.80865108691,-0.794011897097,-0.779372707283,-0.76473351747, + -0.750094327657),.QUASI_UNIFORM_KNOTS.); +#24750 = CARTESIAN_POINT('',(2.349626903915,2.22470066041)); +#24751 = CARTESIAN_POINT('',(2.35199939956,2.214637667881)); +#24752 = CARTESIAN_POINT('',(2.356723099864,2.194451152099)); +#24753 = CARTESIAN_POINT('',(2.363715713671,2.164092387505)); +#24754 = CARTESIAN_POINT('',(2.370587753232,2.133759016752)); +#24755 = CARTESIAN_POINT('',(2.377306589604,2.10354918231)); +#24756 = CARTESIAN_POINT('',(2.383842340737,2.07356946875)); +#24757 = CARTESIAN_POINT('',(2.390171259847,2.043923623504)); +#24758 = CARTESIAN_POINT('',(2.396268669927,2.014743162347)); +#24759 = CARTESIAN_POINT('',(2.402130931221,1.986069391598)); +#24760 = CARTESIAN_POINT('',(2.407691740436,1.958288024377)); +#24761 = CARTESIAN_POINT('',(2.413285456111,1.929725670733)); +#24762 = CARTESIAN_POINT('',(2.418863433081,1.900548130827)); +#24763 = CARTESIAN_POINT('',(2.424397616499,1.870857537053)); +#24764 = CARTESIAN_POINT('',(2.429859181925,1.840773276687)); +#24765 = CARTESIAN_POINT('',(2.435224024411,1.810408918354)); +#24766 = CARTESIAN_POINT('',(2.440470855282,1.779876976094)); +#24767 = CARTESIAN_POINT('',(2.44558181242,1.749285777047)); +#24768 = CARTESIAN_POINT('',(2.450539372006,1.718740047584)); +#24769 = CARTESIAN_POINT('',(2.455327731695,1.68834975922)); +#24770 = CARTESIAN_POINT('',(2.459933753659,1.658229385268)); +#24771 = CARTESIAN_POINT('',(2.464346370328,1.628496510216)); +#24772 = CARTESIAN_POINT('',(2.468556199435,1.599270610968)); +#24773 = CARTESIAN_POINT('',(2.471222627908,1.580204749227)); +#24774 = CARTESIAN_POINT('',(2.47251948349,1.570796326795)); +#24775 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24776 = PCURVE('',#20903,#24777); +#24777 = DEFINITIONAL_REPRESENTATION('',(#24778),#24789); +#24778 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24779,#24780,#24781,#24782, + #24783,#24784,#24785,#24786,#24787,#24788),.UNSPECIFIED.,.F.,.F.,(4, + 2,2,2,4),(-1.072156503551,-1.04598248422,-0.946418753147, + -0.848256540402,-0.750094327657),.UNSPECIFIED.); +#24779 = CARTESIAN_POINT('',(38.122109819926,5.031425563735)); +#24780 = CARTESIAN_POINT('',(38.044850445793,4.976704545222)); +#24781 = CARTESIAN_POINT('',(37.965771517455,4.923620989079)); +#24782 = CARTESIAN_POINT('',(37.57969537956,4.678405891423)); +#24783 = CARTESIAN_POINT('',(37.254304630929,4.515206983342)); +#24784 = CARTESIAN_POINT('',(36.641912478443,4.271545663279)); +#24785 = CARTESIAN_POINT('',(36.298337800896,4.167639114369)); +#24786 = CARTESIAN_POINT('',(35.597365842203,4.031827136925)); +#24787 = CARTESIAN_POINT('',(35.239953394477,4.)); +#24788 = CARTESIAN_POINT('',(34.91274601866,4.)); +#24789 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24790 = ADVANCED_FACE('',(#24791),#24616,.T.); +#24791 = FACE_BOUND('',#24792,.T.); +#24792 = EDGE_LOOP('',(#24793,#24841,#24867,#24868)); +#24793 = ORIENTED_EDGE('',*,*,#24794,.F.); +#24794 = EDGE_CURVE('',#24795,#24797,#24799,.T.); +#24795 = VERTEX_POINT('',#24796); +#24796 = CARTESIAN_POINT('',(-58.,-30.30000000002,13.5)); +#24797 = VERTEX_POINT('',#24798); +#24798 = CARTESIAN_POINT('',(-53.,-28.18571428573,8.5)); +#24799 = SURFACE_CURVE('',#24800,(#24805,#24834),.PCURVE_S1.); +#24800 = ELLIPSE('',#24801,5.428646616021,5.); +#24801 = AXIS2_PLACEMENT_3D('',#24802,#24803,#24804); +#24802 = CARTESIAN_POINT('',(-53.,-28.18571428573,13.5)); +#24803 = DIRECTION('',(0.38946828995,-0.921039874882,1.022559675692E-15) + ); +#24804 = DIRECTION('',(-0.921039874882,-0.38946828995,3.067679027076E-16 + )); +#24805 = PCURVE('',#24616,#24806); +#24806 = DEFINITIONAL_REPRESENTATION('',(#24807),#24833); +#24807 = B_SPLINE_CURVE_WITH_KNOTS('',3,(#24808,#24809,#24810,#24811, + #24812,#24813,#24814,#24815,#24816,#24817,#24818,#24819,#24820, + #24821,#24822,#24823,#24824,#24825,#24826,#24827,#24828,#24829, + #24830,#24831,#24832),.UNSPECIFIED.,.F.,.F.,(4,1,1,1,1,1,1,1,1,1,1,1 + ,1,1,1,1,1,1,1,1,1,1,4),(0.,7.139983303613E-02,0.142799666072, + 0.214199499108,0.285599332145,0.356999165181,0.428398998217, + 0.499798831253,0.571198664289,0.642598497325,0.713998330361, + 0.785398163397,0.856797996434,0.92819782947,0.999597662506, + 1.070997495542,1.142397328578,1.213797161614,1.28519699465, + 1.356596827687,1.427996660723,1.499396493759,1.570796326795), + .QUASI_UNIFORM_KNOTS.); +#24808 = CARTESIAN_POINT('',(-0.785398163397,6.700000000006)); +#24809 = CARTESIAN_POINT('',(-0.761598219052,6.700004559581)); +#24810 = CARTESIAN_POINT('',(-0.713998330361,6.696403526109)); +#24811 = CARTESIAN_POINT('',(-0.642598497325,6.680259073198)); +#24812 = CARTESIAN_POINT('',(-0.571198664289,6.653437900998)); +#24813 = CARTESIAN_POINT('',(-0.499798831253,6.616080994023)); +#24814 = CARTESIAN_POINT('',(-0.428398998217,6.568377559655)); +#24815 = CARTESIAN_POINT('',(-0.356999165181,6.510570993103)); +#24816 = CARTESIAN_POINT('',(-0.285599332145,6.442955780465)); +#24817 = CARTESIAN_POINT('',(-0.214199499108,6.365876495583)); +#24818 = CARTESIAN_POINT('',(-0.142799666072,6.27972591087)); +#24819 = CARTESIAN_POINT('',(-7.139983303613E-02,6.184943031555)); +#24820 = CARTESIAN_POINT('',(3.809110820826E-15,6.082010849037)); +#24821 = CARTESIAN_POINT('',(7.139983303613E-02,5.97145388224)); +#24822 = CARTESIAN_POINT('',(0.142799666072,5.853835504085)); +#24823 = CARTESIAN_POINT('',(0.214199499108,5.729755070912)); +#24824 = CARTESIAN_POINT('',(0.285599332145,5.599844868024)); +#24825 = CARTESIAN_POINT('',(0.356999165181,5.464766888559)); +#24826 = CARTESIAN_POINT('',(0.428398998217,5.325209456995)); +#24827 = CARTESIAN_POINT('',(0.499798831253,5.181883733265)); +#24828 = CARTESIAN_POINT('',(0.571198664289,5.035520045335)); +#24829 = CARTESIAN_POINT('',(0.642598497325,4.886864330039)); +#24830 = CARTESIAN_POINT('',(0.713998330361,4.736673725778)); +#24831 = CARTESIAN_POINT('',(0.761598219052,4.636034559664)); +#24832 = CARTESIAN_POINT('',(0.785398163397,4.585714285719)); +#24833 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24834 = PCURVE('',#21044,#24835); +#24835 = DEFINITIONAL_REPRESENTATION('',(#24836),#24840); +#24836 = ELLIPSE('',#24837,5.428646616021,5.); +#24837 = AXIS2_PLACEMENT_2D('',#24838,#24839); +#24838 = CARTESIAN_POINT('',(5.428646616021,9.)); +#24839 = DIRECTION('',(-1.,-7.894001734057E-17)); +#24840 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24841 = ORIENTED_EDGE('',*,*,#24842,.T.); +#24842 = EDGE_CURVE('',#24795,#24600,#24843,.T.); +#24843 = SURFACE_CURVE('',#24844,(#24848,#24855),.PCURVE_S1.); +#24844 = LINE('',#24845,#24846); +#24845 = CARTESIAN_POINT('',(-58.,-23.60000000001,13.5)); +#24846 = VECTOR('',#24847,1.); +#24847 = DIRECTION('',(2.228178302125E-14,1.,-1.110223024625E-15)); +#24848 = PCURVE('',#24616,#24849); +#24849 = DEFINITIONAL_REPRESENTATION('',(#24850),#24854); +#24850 = LINE('',#24851,#24852); +#24851 = CARTESIAN_POINT('',(-0.785398163397,2.13162820728E-14)); +#24852 = VECTOR('',#24853,1.); +#24853 = DIRECTION('',(2.537652627715E-16,-1.)); +#24854 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24855 = PCURVE('',#24856,#24861); +#24856 = PLANE('',#24857); +#24857 = AXIS2_PLACEMENT_3D('',#24858,#24859,#24860); +#24858 = CARTESIAN_POINT('',(-58.,-30.30000000002,19.8)); +#24859 = DIRECTION('',(-1.,2.228178302125E-14,1.361127932431E-29)); +#24860 = DIRECTION('',(2.228178302125E-14,1.,-8.553453836232E-16)); +#24861 = DEFINITIONAL_REPRESENTATION('',(#24862),#24866); +#24862 = LINE('',#24863,#24864); +#24863 = CARTESIAN_POINT('',(6.700000000006,6.3)); +#24864 = VECTOR('',#24865,1.); +#24865 = DIRECTION('',(1.,2.54877641002E-16)); +#24866 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24867 = ORIENTED_EDGE('',*,*,#24599,.F.); +#24868 = ORIENTED_EDGE('',*,*,#24869,.T.); +#24869 = EDGE_CURVE('',#24562,#24797,#24870,.T.); +#24870 = SURFACE_CURVE('',#24871,(#24875,#24882),.PCURVE_S1.); +#24871 = LINE('',#24872,#24873); +#24872 = CARTESIAN_POINT('',(-53.,-23.60000000001,8.5)); +#24873 = VECTOR('',#24874,1.); +#24874 = DIRECTION('',(-2.228178302125E-14,-1.,1.110223024625E-15)); +#24875 = PCURVE('',#24616,#24876); +#24876 = DEFINITIONAL_REPRESENTATION('',(#24877),#24881); +#24877 = LINE('',#24878,#24879); +#24878 = CARTESIAN_POINT('',(0.785398163397,-3.552713678801E-15)); +#24879 = VECTOR('',#24880,1.); +#24880 = DIRECTION('',(0.,1.)); +#24881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24882 = PCURVE('',#24583,#24883); +#24883 = DEFINITIONAL_REPRESENTATION('',(#24884),#24888); +#24884 = LINE('',#24885,#24886); +#24885 = CARTESIAN_POINT('',(-12.50000000002,-6.700000000006)); +#24886 = VECTOR('',#24887,1.); +#24887 = DIRECTION('',(1.59131966863E-14,-1.)); +#24888 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24889 = ADVANCED_FACE('',(#24890),#24700,.T.); +#24890 = FACE_BOUND('',#24891,.T.); +#24891 = EDGE_LOOP('',(#24892,#24915,#24943,#24964)); +#24892 = ORIENTED_EDGE('',*,*,#24893,.T.); +#24893 = EDGE_CURVE('',#24629,#24894,#24896,.T.); +#24894 = VERTEX_POINT('',#24895); +#24895 = CARTESIAN_POINT('',(-61.52966235425,-18.52107677324,4.5)); +#24896 = SURFACE_CURVE('',#24897,(#24901,#24908),.PCURVE_S1.); +#24897 = LINE('',#24898,#24899); +#24898 = CARTESIAN_POINT('',(-61.52966235425,-18.52107677324,19.8)); +#24899 = VECTOR('',#24900,1.); +#24900 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#24901 = PCURVE('',#24700,#24902); +#24902 = DEFINITIONAL_REPRESENTATION('',(#24903),#24907); +#24903 = LINE('',#24904,#24905); +#24904 = CARTESIAN_POINT('',(0.349266996678,0.)); +#24905 = VECTOR('',#24906,1.); +#24906 = DIRECTION('',(0.,1.)); +#24907 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24908 = PCURVE('',#24645,#24909); +#24909 = DEFINITIONAL_REPRESENTATION('',(#24910),#24914); +#24910 = LINE('',#24911,#24912); +#24911 = CARTESIAN_POINT('',(5.796266908141,-7.105427357601E-15)); +#24912 = VECTOR('',#24913,1.); +#24913 = DIRECTION('',(0.,1.)); +#24914 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24915 = ORIENTED_EDGE('',*,*,#24916,.T.); +#24916 = EDGE_CURVE('',#24894,#24917,#24919,.T.); +#24917 = VERTEX_POINT('',#24918); +#24918 = CARTESIAN_POINT('',(-58.11198325875,-18.34735292086,4.5)); +#24919 = SURFACE_CURVE('',#24920,(#24925,#24932),.PCURVE_S1.); +#24920 = CIRCLE('',#24921,5.); +#24921 = AXIS2_PLACEMENT_3D('',#24922,#24923,#24924); +#24922 = CARTESIAN_POINT('',(-60.0593247085,-13.74215354645,4.5)); +#24923 = DIRECTION('',(3.266640063314E-29,8.553453836232E-16,1.)); +#24924 = DIRECTION('',(5.076540218662E-02,-0.998710605702, + 8.542425061624E-16)); +#24925 = PCURVE('',#24700,#24926); +#24926 = DEFINITIONAL_REPRESENTATION('',(#24927),#24931); +#24927 = LINE('',#24928,#24929); +#24928 = CARTESIAN_POINT('',(6.28318530718,15.3)); +#24929 = VECTOR('',#24930,1.); +#24930 = DIRECTION('',(-1.,0.)); +#24931 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24932 = PCURVE('',#21609,#24933); +#24933 = DEFINITIONAL_REPRESENTATION('',(#24934),#24942); +#24934 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#24935,#24936,#24937,#24938 + ,#24939,#24940,#24941),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#24935 = CARTESIAN_POINT('',(13.155497697591,-3.585706574956)); +#24936 = CARTESIAN_POINT('',(4.506410141926,-3.146065295686)); +#24937 = CARTESIAN_POINT('',(9.211694436158,4.124443607441)); +#24938 = CARTESIAN_POINT('',(13.916978730391,11.394952510568)); +#24939 = CARTESIAN_POINT('',(17.860781991823,3.684802328171)); +#24940 = CARTESIAN_POINT('',(21.804585253256,-4.025347854226)); +#24941 = CARTESIAN_POINT('',(13.155497697591,-3.585706574956)); +#24942 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24943 = ORIENTED_EDGE('',*,*,#24944,.T.); +#24944 = EDGE_CURVE('',#24917,#24658,#24945,.T.); +#24945 = SURFACE_CURVE('',#24946,(#24950,#24957),.PCURVE_S1.); +#24946 = LINE('',#24947,#24948); +#24947 = CARTESIAN_POINT('',(-58.11198325875,-18.34735292086,19.8)); +#24948 = VECTOR('',#24949,1.); +#24949 = DIRECTION('',(-9.14286432779E-17,1.071561769753E-15,1.)); +#24950 = PCURVE('',#24700,#24951); +#24951 = DEFINITIONAL_REPRESENTATION('',(#24952),#24956); +#24952 = LINE('',#24953,#24954); +#24953 = CARTESIAN_POINT('',(-0.349266996678,0.)); +#24954 = VECTOR('',#24955,1.); +#24955 = DIRECTION('',(-1.765261968897E-16,-1.)); +#24956 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24957 = PCURVE('',#20903,#24958); +#24958 = DEFINITIONAL_REPRESENTATION('',(#24959),#24963); +#24959 = LINE('',#24960,#24961); +#24960 = CARTESIAN_POINT('',(38.122109819928,15.3)); +#24961 = VECTOR('',#24962,1.); +#24962 = DIRECTION('',(5.257801617148E-17,1.)); +#24963 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24964 = ORIENTED_EDGE('',*,*,#24657,.F.); +#24965 = ADVANCED_FACE('',(#24966,#25042),#20903,.F.); +#24966 = FACE_BOUND('',#24967,.T.); +#24967 = EDGE_LOOP('',(#24968,#24969,#24992,#25020,#25041)); +#24968 = ORIENTED_EDGE('',*,*,#24944,.F.); +#24969 = ORIENTED_EDGE('',*,*,#24970,.F.); +#24970 = EDGE_CURVE('',#24971,#24917,#24973,.T.); +#24971 = VERTEX_POINT('',#24972); +#24972 = CARTESIAN_POINT('',(-23.45789878249,-3.693625770902,4.5)); +#24973 = SURFACE_CURVE('',#24974,(#24978,#24985),.PCURVE_S1.); +#24974 = LINE('',#24975,#24976); +#24975 = CARTESIAN_POINT('',(-35.12083806539,-8.625382953388,4.5)); +#24976 = VECTOR('',#24977,1.); +#24977 = DIRECTION('',(-0.921039874882,-0.38946828995,3.331299038767E-16 + )); +#24978 = PCURVE('',#20903,#24979); +#24979 = DEFINITIONAL_REPRESENTATION('',(#24980),#24984); +#24980 = LINE('',#24981,#24982); +#24981 = CARTESIAN_POINT('',(13.159949309456,-5.07589667609E-15)); +#24982 = VECTOR('',#24983,1.); +#24983 = DIRECTION('',(1.,-5.257801617149E-17)); +#24984 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24985 = PCURVE('',#21609,#24986); +#24986 = DEFINITIONAL_REPRESENTATION('',(#24987),#24991); +#24987 = LINE('',#24988,#24989); +#24988 = CARTESIAN_POINT('',(-11.52916193458,6.524617046623)); +#24989 = VECTOR('',#24990,1.); +#24990 = DIRECTION('',(0.921039874882,-0.38946828995)); +#24991 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#24992 = ORIENTED_EDGE('',*,*,#24993,.F.); +#24993 = EDGE_CURVE('',#24994,#24971,#24996,.T.); +#24994 = VERTEX_POINT('',#24995); +#24995 = CARTESIAN_POINT('',(-23.45789878249,-3.693625770902,8.5)); +#24996 = SURFACE_CURVE('',#24997,(#25001,#25008),.PCURVE_S1.); +#24997 = LINE('',#24998,#24999); +#24998 = CARTESIAN_POINT('',(-23.45789878249,-3.693625770902,12.15)); +#24999 = VECTOR('',#25000,1.); +#25000 = DIRECTION('',(-2.161867409255E-28,-1.110223024625E-15,-1.)); +#25001 = PCURVE('',#20903,#25002); +#25002 = DEFINITIONAL_REPRESENTATION('',(#25003),#25007); +#25003 = LINE('',#25004,#25005); +#25004 = CARTESIAN_POINT('',(0.497154135262,7.65)); +#25005 = VECTOR('',#25006,1.); +#25006 = DIRECTION('',(4.668874281635E-17,-1.)); +#25007 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25008 = PCURVE('',#25009,#25014); +#25009 = CYLINDRICAL_SURFACE('',#25010,0.75); +#25010 = AXIS2_PLACEMENT_3D('',#25011,#25012,#25013); +#25011 = CARTESIAN_POINT('',(-23.74999999995,-3.002845864741,12.15)); +#25012 = DIRECTION('',(-2.161099318485E-28,-1.110223024625E-15,-1.)); +#25013 = DIRECTION('',(0.833507135527,-0.552508692262,6.134078714547E-16 + )); +#25014 = DEFINITIONAL_REPRESENTATION('',(#25015),#25019); +#25015 = LINE('',#25016,#25017); +#25016 = CARTESIAN_POINT('',(0.585371048898,0.)); +#25017 = VECTOR('',#25018,1.); +#25018 = DIRECTION('',(0.,1.)); +#25019 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25020 = ORIENTED_EDGE('',*,*,#25021,.F.); +#25021 = EDGE_CURVE('',#24560,#24994,#25022,.T.); +#25022 = SURFACE_CURVE('',#25023,(#25027,#25034),.PCURVE_S1.); +#25023 = LINE('',#25024,#25025); +#25024 = CARTESIAN_POINT('',(-32.8261474751,-7.655056646637,8.5)); +#25025 = VECTOR('',#25026,1.); +#25026 = DIRECTION('',(0.921039874882,0.38946828995,-4.323966628644E-16) + ); +#25027 = PCURVE('',#20903,#25028); +#25028 = DEFINITIONAL_REPRESENTATION('',(#25029),#25033); +#25029 = LINE('',#25030,#25031); +#25030 = CARTESIAN_POINT('',(10.6685364479,4.)); +#25031 = VECTOR('',#25032,1.); +#25032 = DIRECTION('',(-1.,-4.668874281616E-17)); +#25033 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25034 = PCURVE('',#24583,#25035); +#25035 = DEFINITIONAL_REPRESENTATION('',(#25036),#25040); +#25036 = LINE('',#25037,#25038); +#25037 = CARTESIAN_POINT('',(7.673852524871,9.244943353375)); +#25038 = VECTOR('',#25039,1.); +#25039 = DIRECTION('',(0.921039874882,0.38946828995)); +#25040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25041 = ORIENTED_EDGE('',*,*,#24734,.F.); +#25042 = FACE_BOUND('',#25043,.T.); +#25043 = EDGE_LOOP('',(#25044)); +#25044 = ORIENTED_EDGE('',*,*,#20866,.T.); +#25045 = ADVANCED_FACE('',(#25046),#21609,.T.); +#25046 = FACE_BOUND('',#25047,.T.); +#25047 = EDGE_LOOP('',(#25048,#25049,#25073,#25094,#25095,#25096,#25097, + #25098,#25099,#25100,#25101,#25102,#25103,#25104,#25125,#25126, + #25127,#25128,#25129,#25152,#25180,#25208,#25231,#25259,#25282, + #25308)); +#25048 = ORIENTED_EDGE('',*,*,#24916,.F.); +#25049 = ORIENTED_EDGE('',*,*,#25050,.F.); +#25050 = EDGE_CURVE('',#25051,#24894,#25053,.T.); +#25051 = VERTEX_POINT('',#25052); +#25052 = CARTESIAN_POINT('',(-63.,-18.30000000002,4.5)); +#25053 = SURFACE_CURVE('',#25054,(#25059,#25066),.PCURVE_S1.); +#25054 = CIRCLE('',#25055,5.); +#25055 = AXIS2_PLACEMENT_3D('',#25056,#25057,#25058); +#25056 = CARTESIAN_POINT('',(-63.,-23.30000000002,4.5)); +#25057 = DIRECTION('',(-3.262140344788E-29,-8.553453836232E-16,-1.)); +#25058 = DIRECTION('',(0.707106781187,0.707106781187,-6.048205210166E-16 + )); +#25059 = PCURVE('',#21609,#25060); +#25060 = DEFINITIONAL_REPRESENTATION('',(#25061),#25065); +#25061 = CIRCLE('',#25062,5.); +#25062 = AXIS2_PLACEMENT_2D('',#25063,#25064); +#25063 = CARTESIAN_POINT('',(16.350000000021,-8.150000000016)); +#25064 = DIRECTION('',(-0.707106781187,0.707106781187)); +#25065 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25066 = PCURVE('',#24645,#25067); +#25067 = DEFINITIONAL_REPRESENTATION('',(#25068),#25072); +#25068 = LINE('',#25069,#25070); +#25069 = CARTESIAN_POINT('',(8.881784197001E-16,15.3)); +#25070 = VECTOR('',#25071,1.); +#25071 = DIRECTION('',(1.,0.)); +#25072 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25073 = ORIENTED_EDGE('',*,*,#25074,.T.); +#25074 = EDGE_CURVE('',#25051,#21789,#25075,.T.); +#25075 = SURFACE_CURVE('',#25076,(#25080,#25087),.PCURVE_S1.); +#25076 = LINE('',#25077,#25078); +#25077 = CARTESIAN_POINT('',(-58.,-18.30000000002,4.5)); +#25078 = VECTOR('',#25079,1.); +#25079 = DIRECTION('',(-1.,4.036126853609E-14,-2.012869368759E-30)); +#25080 = PCURVE('',#21609,#25081); +#25081 = DEFINITIONAL_REPRESENTATION('',(#25082),#25086); +#25082 = LINE('',#25083,#25084); +#25083 = CARTESIAN_POINT('',(11.350000000021,-3.150000000016)); +#25084 = VECTOR('',#25085,1.); +#25085 = DIRECTION('',(1.,2.166288828537E-15)); +#25086 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25087 = PCURVE('',#21827,#25088); +#25088 = DEFINITIONAL_REPRESENTATION('',(#25089),#25093); +#25089 = LINE('',#25090,#25091); +#25090 = CARTESIAN_POINT('',(1.20855285118E-32,15.3)); +#25091 = VECTOR('',#25092,1.); +#25092 = DIRECTION('',(1.,0.)); +#25093 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25094 = ORIENTED_EDGE('',*,*,#21788,.F.); +#25095 = ORIENTED_EDGE('',*,*,#22042,.T.); +#25096 = ORIENTED_EDGE('',*,*,#22122,.T.); +#25097 = ORIENTED_EDGE('',*,*,#21593,.T.); +#25098 = ORIENTED_EDGE('',*,*,#21895,.F.); +#25099 = ORIENTED_EDGE('',*,*,#23509,.F.); +#25100 = ORIENTED_EDGE('',*,*,#23296,.T.); +#25101 = ORIENTED_EDGE('',*,*,#23120,.T.); +#25102 = ORIENTED_EDGE('',*,*,#23198,.F.); +#25103 = ORIENTED_EDGE('',*,*,#23555,.T.); +#25104 = ORIENTED_EDGE('',*,*,#25105,.F.); +#25105 = EDGE_CURVE('',#23629,#23556,#25106,.T.); +#25106 = SURFACE_CURVE('',#25107,(#25111,#25118),.PCURVE_S1.); +#25107 = LINE('',#25108,#25109); +#25108 = CARTESIAN_POINT('',(-22.99999999995,-5.02493206569E-15,4.5)); +#25109 = VECTOR('',#25110,1.); +#25110 = DIRECTION('',(-7.197229586486E-13,1.,-8.553453836232E-16)); +#25111 = PCURVE('',#21609,#25112); +#25112 = DEFINITIONAL_REPRESENTATION('',(#25113),#25117); +#25113 = LINE('',#25114,#25115); +#25114 = CARTESIAN_POINT('',(-23.65000000002,15.150000000011)); +#25115 = VECTOR('',#25116,1.); +#25116 = DIRECTION('',(7.579179383562E-13,1.)); +#25117 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25118 = PCURVE('',#20548,#25119); +#25119 = DEFINITIONAL_REPRESENTATION('',(#25120),#25124); +#25120 = LINE('',#25121,#25122); +#25121 = CARTESIAN_POINT('',(-4.233144021558E-27,15.3)); +#25122 = VECTOR('',#25123,1.); +#25123 = DIRECTION('',(-1.,-9.860761315263E-31)); +#25124 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25125 = ORIENTED_EDGE('',*,*,#23628,.T.); +#25126 = ORIENTED_EDGE('',*,*,#23782,.F.); +#25127 = ORIENTED_EDGE('',*,*,#24274,.F.); +#25128 = ORIENTED_EDGE('',*,*,#24432,.F.); +#25129 = ORIENTED_EDGE('',*,*,#25130,.F.); +#25130 = EDGE_CURVE('',#25131,#24405,#25133,.T.); +#25131 = VERTEX_POINT('',#25132); +#25132 = CARTESIAN_POINT('',(-59.3,-4.599999999996,4.5)); +#25133 = SURFACE_CURVE('',#25134,(#25138,#25145),.PCURVE_S1.); +#25134 = LINE('',#25135,#25136); +#25135 = CARTESIAN_POINT('',(-59.3,-4.599345146313E-12,4.5)); +#25136 = VECTOR('',#25137,1.); +#25137 = DIRECTION('',(-4.688861576103E-14,1.,-8.553453836232E-16)); +#25138 = PCURVE('',#21609,#25139); +#25139 = DEFINITIONAL_REPRESENTATION('',(#25140),#25144); +#25140 = LINE('',#25141,#25142); +#25141 = CARTESIAN_POINT('',(12.650000000022,15.150000000005)); +#25142 = VECTOR('',#25143,1.); +#25143 = DIRECTION('',(8.508359546858E-14,1.)); +#25144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25145 = PCURVE('',#24420,#25146); +#25146 = DEFINITIONAL_REPRESENTATION('',(#25147),#25151); +#25147 = LINE('',#25148,#25149); +#25148 = CARTESIAN_POINT('',(9.18846131988E-12,15.3)); +#25149 = VECTOR('',#25150,1.); +#25150 = DIRECTION('',(-1.,0.)); +#25151 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25152 = ORIENTED_EDGE('',*,*,#25153,.T.); +#25153 = EDGE_CURVE('',#25131,#25154,#25156,.T.); +#25154 = VERTEX_POINT('',#25155); +#25155 = CARTESIAN_POINT('',(-38.7,-4.599999999996,4.5)); +#25156 = SURFACE_CURVE('',#25157,(#25161,#25168),.PCURVE_S1.); +#25157 = LINE('',#25158,#25159); +#25158 = CARTESIAN_POINT('',(-59.3,-4.599999999996,4.5)); +#25159 = VECTOR('',#25160,1.); +#25160 = DIRECTION('',(1.,-2.786410427028E-15,-3.012661205512E-29)); +#25161 = PCURVE('',#21609,#25162); +#25162 = DEFINITIONAL_REPRESENTATION('',(#25163),#25167); +#25163 = LINE('',#25164,#25165); +#25164 = CARTESIAN_POINT('',(12.650000000022,10.550000000013)); +#25165 = VECTOR('',#25166,1.); +#25166 = DIRECTION('',(-1.,3.540856928052E-14)); +#25167 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25168 = PCURVE('',#25169,#25174); +#25169 = PLANE('',#25170); +#25170 = AXIS2_PLACEMENT_3D('',#25171,#25172,#25173); +#25171 = CARTESIAN_POINT('',(-59.3,-4.599999999996,19.8)); +#25172 = DIRECTION('',(2.786410427028E-15,1.,-8.553453836232E-16)); +#25173 = DIRECTION('',(1.,-2.786410427028E-15,-3.012661205512E-29)); +#25174 = DEFINITIONAL_REPRESENTATION('',(#25175),#25179); +#25175 = LINE('',#25176,#25177); +#25176 = CARTESIAN_POINT('',(-1.079974216791E-29,15.3)); +#25177 = VECTOR('',#25178,1.); +#25178 = DIRECTION('',(1.,0.)); +#25179 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25180 = ORIENTED_EDGE('',*,*,#25181,.T.); +#25181 = EDGE_CURVE('',#25154,#25182,#25184,.T.); +#25182 = VERTEX_POINT('',#25183); +#25183 = CARTESIAN_POINT('',(-38.7,-1.999999999996,4.5)); +#25184 = SURFACE_CURVE('',#25185,(#25189,#25196),.PCURVE_S1.); +#25185 = LINE('',#25186,#25187); +#25186 = CARTESIAN_POINT('',(-38.7,-4.599999999996,4.5)); +#25187 = VECTOR('',#25188,1.); +#25188 = DIRECTION('',(3.862198856317E-14,1.,-8.553453836232E-16)); +#25189 = PCURVE('',#21609,#25190); +#25190 = DEFINITIONAL_REPRESENTATION('',(#25191),#25195); +#25191 = LINE('',#25192,#25193); +#25192 = CARTESIAN_POINT('',(-7.949999999978,10.550000000014)); +#25193 = VECTOR('',#25194,1.); +#25194 = DIRECTION('',(-4.270088556251E-16,1.)); +#25195 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25196 = PCURVE('',#25197,#25202); +#25197 = PLANE('',#25198); +#25198 = AXIS2_PLACEMENT_3D('',#25199,#25200,#25201); +#25199 = CARTESIAN_POINT('',(-38.7,-4.599999999996,19.8)); +#25200 = DIRECTION('',(-1.,3.862198856317E-14,-3.652400534251E-31)); +#25201 = DIRECTION('',(3.862198856317E-14,1.,-8.553453836232E-16)); +#25202 = DEFINITIONAL_REPRESENTATION('',(#25203),#25207); +#25203 = LINE('',#25204,#25205); +#25204 = CARTESIAN_POINT('',(3.316821752733E-15,15.3)); +#25205 = VECTOR('',#25206,1.); +#25206 = DIRECTION('',(1.,0.)); +#25207 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25208 = ORIENTED_EDGE('',*,*,#25209,.T.); +#25209 = EDGE_CURVE('',#25182,#25210,#25212,.T.); +#25210 = VERTEX_POINT('',#25211); +#25211 = CARTESIAN_POINT('',(-23.74999999995,-1.999999999997,4.5)); +#25212 = SURFACE_CURVE('',#25213,(#25217,#25224),.PCURVE_S1.); +#25213 = LINE('',#25214,#25215); +#25214 = CARTESIAN_POINT('',(-36.7,-1.999999999996,4.5)); +#25215 = VECTOR('',#25216,1.); +#25216 = DIRECTION('',(1.,-3.847253546371E-14,3.973502544019E-31)); +#25217 = PCURVE('',#21609,#25218); +#25218 = DEFINITIONAL_REPRESENTATION('',(#25219),#25223); +#25219 = LINE('',#25220,#25221); +#25220 = CARTESIAN_POINT('',(-9.949999999978,13.150000000014)); +#25221 = VECTOR('',#25222,1.); +#25222 = DIRECTION('',(-1.,-2.775557561563E-16)); +#25223 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25224 = PCURVE('',#20430,#25225); +#25225 = DEFINITIONAL_REPRESENTATION('',(#25226),#25230); +#25226 = LINE('',#25227,#25228); +#25227 = CARTESIAN_POINT('',(2.,15.3)); +#25228 = VECTOR('',#25229,1.); +#25229 = DIRECTION('',(1.,0.)); +#25230 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25231 = ORIENTED_EDGE('',*,*,#25232,.F.); +#25232 = EDGE_CURVE('',#25233,#25210,#25235,.T.); +#25233 = VERTEX_POINT('',#25234); +#25234 = CARTESIAN_POINT('',(-22.99999999995,-2.749999999997,4.5)); +#25235 = SURFACE_CURVE('',#25236,(#25241,#25252),.PCURVE_S1.); +#25236 = CIRCLE('',#25237,0.75); +#25237 = AXIS2_PLACEMENT_3D('',#25238,#25239,#25240); +#25238 = CARTESIAN_POINT('',(-23.74999999995,-2.749999999997,4.5)); +#25239 = DIRECTION('',(3.262710464747E-29,8.553453836232E-16,1.)); +#25240 = DIRECTION('',(0.707106781187,0.707106781186,-6.048205210164E-16 + )); +#25241 = PCURVE('',#21609,#25242); +#25242 = DEFINITIONAL_REPRESENTATION('',(#25243),#25251); +#25243 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#25244,#25245,#25246,#25247 + ,#25248,#25249,#25250),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#25244 = CARTESIAN_POINT('',(-23.4303300859,12.930330085904)); +#25245 = CARTESIAN_POINT('',(-22.51177143236,13.848888739448)); +#25246 = CARTESIAN_POINT('',(-22.1755556303,12.594114283841)); +#25247 = CARTESIAN_POINT('',(-21.83933982823,11.339339828235)); +#25248 = CARTESIAN_POINT('',(-23.09411428384,11.675555630297)); +#25249 = CARTESIAN_POINT('',(-24.34888873945,12.01177143236)); +#25250 = CARTESIAN_POINT('',(-23.4303300859,12.930330085904)); +#25251 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25252 = PCURVE('',#20577,#25253); +#25253 = DEFINITIONAL_REPRESENTATION('',(#25254),#25258); +#25254 = LINE('',#25255,#25256); +#25255 = CARTESIAN_POINT('',(-6.28318530718,-15.3)); +#25256 = VECTOR('',#25257,1.); +#25257 = DIRECTION('',(1.,0.)); +#25258 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25259 = ORIENTED_EDGE('',*,*,#25260,.T.); +#25260 = EDGE_CURVE('',#25233,#25261,#25263,.T.); +#25261 = VERTEX_POINT('',#25262); +#25262 = CARTESIAN_POINT('',(-22.99999999995,-3.002845864741,4.5)); +#25263 = SURFACE_CURVE('',#25264,(#25268,#25275),.PCURVE_S1.); +#25264 = LINE('',#25265,#25266); +#25265 = CARTESIAN_POINT('',(-22.99999999995,-5.02493206569E-15,4.5)); +#25266 = VECTOR('',#25267,1.); +#25267 = DIRECTION('',(-7.19718024527E-13,-1.,8.553453836232E-16)); +#25268 = PCURVE('',#21609,#25269); +#25269 = DEFINITIONAL_REPRESENTATION('',(#25270),#25274); +#25270 = LINE('',#25271,#25272); +#25271 = CARTESIAN_POINT('',(-23.65000000002,15.150000000011)); +#25272 = VECTOR('',#25273,1.); +#25273 = DIRECTION('',(6.815230448195E-13,-1.)); +#25274 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25275 = PCURVE('',#20548,#25276); +#25276 = DEFINITIONAL_REPRESENTATION('',(#25277),#25281); +#25277 = LINE('',#25278,#25279); +#25278 = CARTESIAN_POINT('',(-4.233144021558E-27,15.3)); +#25279 = VECTOR('',#25280,1.); +#25280 = DIRECTION('',(1.,0.)); +#25281 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25282 = ORIENTED_EDGE('',*,*,#25283,.F.); +#25283 = EDGE_CURVE('',#24971,#25261,#25284,.T.); +#25284 = SURFACE_CURVE('',#25285,(#25290,#25301),.PCURVE_S1.); +#25285 = CIRCLE('',#25286,0.75); +#25286 = AXIS2_PLACEMENT_3D('',#25287,#25288,#25289); +#25287 = CARTESIAN_POINT('',(-23.74999999995,-3.002845864741,4.5)); +#25288 = DIRECTION('',(3.271729875158E-29,8.553453836232E-16,1.)); +#25289 = DIRECTION('',(0.833507135527,-0.552508692262,4.72585759338E-16) + ); +#25290 = PCURVE('',#21609,#25291); +#25291 = DEFINITIONAL_REPRESENTATION('',(#25292),#25300); +#25292 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#25293,#25294,#25295,#25296 + ,#25297,#25298,#25299),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#25293 = CARTESIAN_POINT('',(-23.52513035166,11.732772616074)); +#25294 = CARTESIAN_POINT('',(-24.24286019663,12.815530146477)); +#25295 = CARTESIAN_POINT('',(-22.94629974667,12.89572366007)); +#25296 = CARTESIAN_POINT('',(-21.64973929672,12.975917173663)); +#25297 = CARTESIAN_POINT('',(-22.22856990171,11.812966129667)); +#25298 = CARTESIAN_POINT('',(-22.80740050669,10.65001508567)); +#25299 = CARTESIAN_POINT('',(-23.52513035166,11.732772616074)); +#25300 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25301 = PCURVE('',#25009,#25302); +#25302 = DEFINITIONAL_REPRESENTATION('',(#25303),#25307); +#25303 = LINE('',#25304,#25305); +#25304 = CARTESIAN_POINT('',(6.28318530718,7.65)); +#25305 = VECTOR('',#25306,1.); +#25306 = DIRECTION('',(-1.,0.)); +#25307 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25308 = ORIENTED_EDGE('',*,*,#24970,.T.); +#25309 = ADVANCED_FACE('',(#25310),#24645,.F.); +#25310 = FACE_BOUND('',#25311,.F.); +#25311 = EDGE_LOOP('',(#25312,#25313,#25336,#25364,#25385,#25386)); +#25312 = ORIENTED_EDGE('',*,*,#25050,.F.); +#25313 = ORIENTED_EDGE('',*,*,#25314,.F.); +#25314 = EDGE_CURVE('',#25315,#25051,#25317,.T.); +#25315 = VERTEX_POINT('',#25316); +#25316 = CARTESIAN_POINT('',(-63.,-18.30000000002,19.8)); +#25317 = SURFACE_CURVE('',#25318,(#25322,#25329),.PCURVE_S1.); +#25318 = LINE('',#25319,#25320); +#25319 = CARTESIAN_POINT('',(-63.,-18.30000000002,19.8)); +#25320 = VECTOR('',#25321,1.); +#25321 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25322 = PCURVE('',#24645,#25323); +#25323 = DEFINITIONAL_REPRESENTATION('',(#25324),#25328); +#25324 = LINE('',#25325,#25326); +#25325 = CARTESIAN_POINT('',(5.497787143782,-7.105427357601E-15)); +#25326 = VECTOR('',#25327,1.); +#25327 = DIRECTION('',(0.,1.)); +#25328 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25329 = PCURVE('',#21827,#25330); +#25330 = DEFINITIONAL_REPRESENTATION('',(#25331),#25335); +#25331 = LINE('',#25332,#25333); +#25332 = CARTESIAN_POINT('',(5.,-9.916112831869E-30)); +#25333 = VECTOR('',#25334,1.); +#25334 = DIRECTION('',(1.599442196756E-31,1.)); +#25335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25336 = ORIENTED_EDGE('',*,*,#25337,.F.); +#25337 = EDGE_CURVE('',#25338,#25315,#25340,.T.); +#25338 = VERTEX_POINT('',#25339); +#25339 = CARTESIAN_POINT('',(-58.,-23.30000000002,19.8)); +#25340 = SURFACE_CURVE('',#25341,(#25346,#25353),.PCURVE_S1.); +#25341 = CIRCLE('',#25342,5.); +#25342 = AXIS2_PLACEMENT_3D('',#25343,#25344,#25345); +#25343 = CARTESIAN_POINT('',(-63.,-23.30000000002,19.8)); +#25344 = DIRECTION('',(3.250732881157E-29,8.553453836232E-16,1.)); +#25345 = DIRECTION('',(0.707106781187,0.707106781187,-6.048205210166E-16 + )); +#25346 = PCURVE('',#24645,#25347); +#25347 = DEFINITIONAL_REPRESENTATION('',(#25348),#25352); +#25348 = LINE('',#25349,#25350); +#25349 = CARTESIAN_POINT('',(12.566370614359,0.)); +#25350 = VECTOR('',#25351,1.); +#25351 = DIRECTION('',(-1.,0.)); +#25352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25353 = PCURVE('',#21855,#25354); +#25354 = DEFINITIONAL_REPRESENTATION('',(#25355),#25363); +#25355 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#25356,#25357,#25358,#25359 + ,#25360,#25361,#25362),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#25356 = CARTESIAN_POINT('',(-12.81446609408,4.614466094083)); +#25357 = CARTESIAN_POINT('',(-18.93819045104,-1.509258262874)); +#25358 = CARTESIAN_POINT('',(-21.17962913146,6.855904774504)); +#25359 = CARTESIAN_POINT('',(-23.42106781188,15.221067811882)); +#25360 = CARTESIAN_POINT('',(-15.0559047745,12.979629131462)); +#25361 = CARTESIAN_POINT('',(-6.69074173713,10.738190451041)); +#25362 = CARTESIAN_POINT('',(-12.81446609408,4.614466094083)); +#25363 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25364 = ORIENTED_EDGE('',*,*,#25365,.F.); +#25365 = EDGE_CURVE('',#24600,#25338,#25366,.T.); +#25366 = SURFACE_CURVE('',#25367,(#25371,#25378),.PCURVE_S1.); +#25367 = LINE('',#25368,#25369); +#25368 = CARTESIAN_POINT('',(-58.,-23.30000000002,19.8)); +#25369 = VECTOR('',#25370,1.); +#25370 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#25371 = PCURVE('',#24645,#25372); +#25372 = DEFINITIONAL_REPRESENTATION('',(#25373),#25377); +#25373 = LINE('',#25374,#25375); +#25374 = CARTESIAN_POINT('',(7.068583470577,-7.105427357601E-15)); +#25375 = VECTOR('',#25376,1.); +#25376 = DIRECTION('',(0.,-1.)); +#25377 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25378 = PCURVE('',#24856,#25379); +#25379 = DEFINITIONAL_REPRESENTATION('',(#25380),#25384); +#25380 = LINE('',#25381,#25382); +#25381 = CARTESIAN_POINT('',(6.999999999998,-5.987417685361E-15)); +#25382 = VECTOR('',#25383,1.); +#25383 = DIRECTION('',(-9.860761315263E-31,-1.)); +#25384 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25385 = ORIENTED_EDGE('',*,*,#24628,.T.); +#25386 = ORIENTED_EDGE('',*,*,#24893,.T.); +#25387 = ADVANCED_FACE('',(#25388),#25403,.T.); +#25388 = FACE_BOUND('',#25389,.T.); +#25389 = EDGE_LOOP('',(#25390,#25430,#25453,#25477)); +#25390 = ORIENTED_EDGE('',*,*,#25391,.T.); +#25391 = EDGE_CURVE('',#25392,#25394,#25396,.T.); +#25392 = VERTEX_POINT('',#25393); +#25393 = CARTESIAN_POINT('',(-22.99999999997,-18.51717293212,4.5)); +#25394 = VERTEX_POINT('',#25395); +#25395 = CARTESIAN_POINT('',(-25.77893657987,-16.67509318236,4.5)); +#25396 = SURFACE_CURVE('',#25397,(#25402,#25414),.PCURVE_S1.); +#25397 = CIRCLE('',#25398,2.); +#25398 = AXIS2_PLACEMENT_3D('',#25399,#25400,#25401); +#25399 = CARTESIAN_POINT('',(-24.99999999997,-18.51717293212,4.5)); +#25400 = DIRECTION('',(3.274792255322E-29,8.553453836232E-16,1.)); +#25401 = DIRECTION('',(0.552508692262,0.833507135527,-7.129364805902E-16 + )); +#25402 = PCURVE('',#25403,#25408); +#25403 = CYLINDRICAL_SURFACE('',#25404,2.); +#25404 = AXIS2_PLACEMENT_3D('',#25405,#25406,#25407); +#25405 = CARTESIAN_POINT('',(-24.99999999997,-18.51717293212,12.15)); +#25406 = DIRECTION('',(2.161099318485E-28,1.110223024625E-15,1.)); +#25407 = DIRECTION('',(0.552508692262,0.833507135527,-9.253788130519E-16 + )); +#25408 = DEFINITIONAL_REPRESENTATION('',(#25409),#25413); +#25409 = LINE('',#25410,#25411); +#25410 = CARTESIAN_POINT('',(3.552713678801E-15,-7.65)); +#25411 = VECTOR('',#25412,1.); +#25412 = DIRECTION('',(1.,0.)); +#25413 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25414 = PCURVE('',#25415,#25420); +#25415 = PLANE('',#25416); +#25416 = AXIS2_PLACEMENT_3D('',#25417,#25418,#25419); +#25417 = CARTESIAN_POINT('',(-46.64999999997,-15.15000000001,4.5)); +#25418 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25419 = DIRECTION('',(-1.,3.819497970755E-14,2.24207754292E-44)); +#25420 = DEFINITIONAL_REPRESENTATION('',(#25421),#25429); +#25421 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#25422,#25423,#25424,#25425 + ,#25426,#25427,#25428),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#25422 = CARTESIAN_POINT('',(-22.75501738453,-1.700158661061)); +#25423 = CARTESIAN_POINT('',(-19.86766397012,0.213787592181)); +#25424 = CARTESIAN_POINT('',(-19.65381460054,-3.243706941022)); +#25425 = CARTESIAN_POINT('',(-19.43996523096,-6.701201474225)); +#25426 = CARTESIAN_POINT('',(-22.54116801495,-5.157653194264)); +#25427 = CARTESIAN_POINT('',(-25.64237079894,-3.614104914304)); +#25428 = CARTESIAN_POINT('',(-22.75501738453,-1.700158661061)); +#25429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25430 = ORIENTED_EDGE('',*,*,#25431,.T.); +#25431 = EDGE_CURVE('',#25394,#25432,#25434,.T.); +#25432 = VERTEX_POINT('',#25433); +#25433 = CARTESIAN_POINT('',(-25.77893657987,-16.67509318236,8.5)); +#25434 = SURFACE_CURVE('',#25435,(#25439,#25446),.PCURVE_S1.); +#25435 = LINE('',#25436,#25437); +#25436 = CARTESIAN_POINT('',(-25.77893657987,-16.67509318236,12.15)); +#25437 = VECTOR('',#25438,1.); +#25438 = DIRECTION('',(2.161099318485E-28,1.110223024625E-15,1.)); +#25439 = PCURVE('',#25403,#25440); +#25440 = DEFINITIONAL_REPRESENTATION('',(#25441),#25445); +#25441 = LINE('',#25442,#25443); +#25442 = CARTESIAN_POINT('',(7.268610585076,0.)); +#25443 = VECTOR('',#25444,1.); +#25444 = DIRECTION('',(-2.22044604925E-16,1.)); +#25445 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25446 = PCURVE('',#21044,#25447); +#25447 = DEFINITIONAL_REPRESENTATION('',(#25448),#25452); +#25448 = LINE('',#25449,#25450); +#25449 = CARTESIAN_POINT('',(34.983353380057,7.65)); +#25450 = VECTOR('',#25451,1.); +#25451 = DIRECTION('',(4.668874281635E-17,1.)); +#25452 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25453 = ORIENTED_EDGE('',*,*,#25454,.F.); +#25454 = EDGE_CURVE('',#25455,#25432,#25457,.T.); +#25455 = VERTEX_POINT('',#25456); +#25456 = CARTESIAN_POINT('',(-22.99999999997,-18.51717293212,8.5)); +#25457 = SURFACE_CURVE('',#25458,(#25463,#25470),.PCURVE_S1.); +#25458 = CIRCLE('',#25459,2.); +#25459 = AXIS2_PLACEMENT_3D('',#25460,#25461,#25462); +#25460 = CARTESIAN_POINT('',(-24.99999999997,-18.51717293212,8.5)); +#25461 = DIRECTION('',(4.233426874492E-29,1.110223024625E-15,1.)); +#25462 = DIRECTION('',(0.552508692262,0.833507135527,-9.253788130518E-16 + )); +#25463 = PCURVE('',#25403,#25464); +#25464 = DEFINITIONAL_REPRESENTATION('',(#25465),#25469); +#25465 = LINE('',#25466,#25467); +#25466 = CARTESIAN_POINT('',(1.7763568394E-15,-3.65)); +#25467 = VECTOR('',#25468,1.); +#25468 = DIRECTION('',(1.,0.)); +#25469 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25470 = PCURVE('',#24583,#25471); +#25471 = DEFINITIONAL_REPRESENTATION('',(#25472),#25476); +#25472 = CIRCLE('',#25473,2.); +#25473 = AXIS2_PLACEMENT_2D('',#25474,#25475); +#25474 = CARTESIAN_POINT('',(15.500000000008,-1.617172932114)); +#25475 = DIRECTION('',(0.552508692262,0.833507135527)); +#25476 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25477 = ORIENTED_EDGE('',*,*,#25478,.T.); +#25478 = EDGE_CURVE('',#25455,#25392,#25479,.T.); +#25479 = SURFACE_CURVE('',#25480,(#25484,#25491),.PCURVE_S1.); +#25480 = LINE('',#25481,#25482); +#25481 = CARTESIAN_POINT('',(-22.99999999997,-18.51717293212,12.15)); +#25482 = VECTOR('',#25483,1.); +#25483 = DIRECTION('',(-2.161099318485E-28,-1.110223024625E-15,-1.)); +#25484 = PCURVE('',#25403,#25485); +#25485 = DEFINITIONAL_REPRESENTATION('',(#25486),#25490); +#25486 = LINE('',#25487,#25488); +#25487 = CARTESIAN_POINT('',(5.297760029283,0.)); +#25488 = VECTOR('',#25489,1.); +#25489 = DIRECTION('',(2.22044604925E-16,-1.)); +#25490 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25491 = PCURVE('',#20548,#25492); +#25492 = DEFINITIONAL_REPRESENTATION('',(#25493),#25497); +#25493 = LINE('',#25494,#25495); +#25494 = CARTESIAN_POINT('',(18.517172932128,7.65)); +#25495 = VECTOR('',#25496,1.); +#25496 = DIRECTION('',(2.54877641002E-16,1.)); +#25497 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25498 = ADVANCED_FACE('',(#25499),#25415,.T.); +#25499 = FACE_BOUND('',#25500,.T.); +#25500 = EDGE_LOOP('',(#25501,#25502,#25525,#25548)); +#25501 = ORIENTED_EDGE('',*,*,#25391,.F.); +#25502 = ORIENTED_EDGE('',*,*,#25503,.T.); +#25503 = EDGE_CURVE('',#25392,#25504,#25506,.T.); +#25504 = VERTEX_POINT('',#25505); +#25505 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,4.5)); +#25506 = SURFACE_CURVE('',#25507,(#25511,#25518),.PCURVE_S1.); +#25507 = LINE('',#25508,#25509); +#25508 = CARTESIAN_POINT('',(-22.99999999995,-5.02493206569E-15,4.5)); +#25509 = VECTOR('',#25510,1.); +#25510 = DIRECTION('',(-7.19718024527E-13,-1.,8.553453836232E-16)); +#25511 = PCURVE('',#25415,#25512); +#25512 = DEFINITIONAL_REPRESENTATION('',(#25513),#25517); +#25513 = LINE('',#25514,#25515); +#25514 = CARTESIAN_POINT('',(-23.65000000002,15.150000000011)); +#25515 = VECTOR('',#25516,1.); +#25516 = DIRECTION('',(6.815230448195E-13,-1.)); +#25517 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25518 = PCURVE('',#20548,#25519); +#25519 = DEFINITIONAL_REPRESENTATION('',(#25520),#25524); +#25520 = LINE('',#25521,#25522); +#25521 = CARTESIAN_POINT('',(-4.233144021558E-27,15.3)); +#25522 = VECTOR('',#25523,1.); +#25523 = DIRECTION('',(1.,0.)); +#25524 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25525 = ORIENTED_EDGE('',*,*,#25526,.T.); +#25526 = EDGE_CURVE('',#25504,#25527,#25529,.T.); +#25527 = VERTEX_POINT('',#25528); +#25528 = CARTESIAN_POINT('',(-58.,-30.30000000002,4.5)); +#25529 = SURFACE_CURVE('',#25530,(#25534,#25541),.PCURVE_S1.); +#25530 = LINE('',#25531,#25532); +#25531 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,4.5)); +#25532 = VECTOR('',#25533,1.); +#25533 = DIRECTION('',(-1.,-7.556262188718E-13,6.788313534074E-28)); +#25534 = PCURVE('',#25415,#25535); +#25535 = DEFINITIONAL_REPRESENTATION('',(#25536),#25540); +#25536 = LINE('',#25537,#25538); +#25537 = CARTESIAN_POINT('',(-23.65,-15.14999999998)); +#25538 = VECTOR('',#25539,1.); +#25539 = DIRECTION('',(1.,-7.938211985794E-13)); +#25540 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25541 = PCURVE('',#20990,#25542); +#25542 = DEFINITIONAL_REPRESENTATION('',(#25543),#25547); +#25543 = LINE('',#25544,#25545); +#25544 = CARTESIAN_POINT('',(8.947580157256E-28,15.3)); +#25545 = VECTOR('',#25546,1.); +#25546 = DIRECTION('',(1.,-1.793662034336E-43)); +#25547 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25548 = ORIENTED_EDGE('',*,*,#25549,.T.); +#25549 = EDGE_CURVE('',#25527,#25394,#25550,.T.); +#25550 = SURFACE_CURVE('',#25551,(#25555,#25562),.PCURVE_S1.); +#25551 = LINE('',#25552,#25553); +#25552 = CARTESIAN_POINT('',(-50.46854311513,-27.11526966013,4.5)); +#25553 = VECTOR('',#25554,1.); +#25554 = DIRECTION('',(0.921039874882,0.38946828995,-3.331299038767E-16) + ); +#25555 = PCURVE('',#25415,#25556); +#25556 = DEFINITIONAL_REPRESENTATION('',(#25557),#25561); +#25557 = LINE('',#25558,#25559); +#25558 = CARTESIAN_POINT('',(3.818543115158,-11.96526966012)); +#25559 = VECTOR('',#25560,1.); +#25560 = DIRECTION('',(-0.921039874882,0.38946828995)); +#25561 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25562 = PCURVE('',#21044,#25563); +#25563 = DEFINITIONAL_REPRESENTATION('',(#25564),#25568); +#25564 = LINE('',#25565,#25566); +#25565 = CARTESIAN_POINT('',(8.177123586344,3.153981330466E-15)); +#25566 = VECTOR('',#25567,1.); +#25567 = DIRECTION('',(1.,5.257801617149E-17)); +#25568 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25569 = ADVANCED_FACE('',(#25570),#20548,.T.); +#25570 = FACE_BOUND('',#25571,.T.); +#25571 = EDGE_LOOP('',(#25572,#25573,#25596,#25617,#25618,#25639,#25640, + #25641,#25642,#25643,#25644,#25645,#25646,#25647,#25670,#25691)); +#25572 = ORIENTED_EDGE('',*,*,#25478,.F.); +#25573 = ORIENTED_EDGE('',*,*,#25574,.T.); +#25574 = EDGE_CURVE('',#25455,#25575,#25577,.T.); +#25575 = VERTEX_POINT('',#25576); +#25576 = CARTESIAN_POINT('',(-22.99999999995,-3.002845864741,8.5)); +#25577 = SURFACE_CURVE('',#25578,(#25582,#25589),.PCURVE_S1.); +#25578 = LINE('',#25579,#25580); +#25579 = CARTESIAN_POINT('',(-22.99999999996,-8.450000000012,8.5)); +#25580 = VECTOR('',#25581,1.); +#25581 = DIRECTION('',(7.19718024527E-13,1.,-1.110223024625E-15)); +#25582 = PCURVE('',#20548,#25583); +#25583 = DEFINITIONAL_REPRESENTATION('',(#25584),#25588); +#25584 = LINE('',#25585,#25586); +#25585 = CARTESIAN_POINT('',(8.450000000012,11.3)); +#25586 = VECTOR('',#25587,1.); +#25587 = DIRECTION('',(-1.,2.54877641002E-16)); +#25588 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25589 = PCURVE('',#24583,#25590); +#25590 = DEFINITIONAL_REPRESENTATION('',(#25591),#25595); +#25591 = LINE('',#25592,#25593); +#25592 = CARTESIAN_POINT('',(17.500000000015,8.45)); +#25593 = VECTOR('',#25594,1.); +#25594 = DIRECTION('',(6.815230448195E-13,1.)); +#25595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25596 = ORIENTED_EDGE('',*,*,#25597,.F.); +#25597 = EDGE_CURVE('',#25261,#25575,#25598,.T.); +#25598 = SURFACE_CURVE('',#25599,(#25603,#25610),.PCURVE_S1.); +#25599 = LINE('',#25600,#25601); +#25600 = CARTESIAN_POINT('',(-22.99999999995,-3.002845864741,12.15)); +#25601 = VECTOR('',#25602,1.); +#25602 = DIRECTION('',(2.161099318485E-28,1.110223024625E-15,1.)); +#25603 = PCURVE('',#20548,#25604); +#25604 = DEFINITIONAL_REPRESENTATION('',(#25605),#25609); +#25605 = LINE('',#25606,#25607); +#25606 = CARTESIAN_POINT('',(3.002845864741,7.65)); +#25607 = VECTOR('',#25608,1.); +#25608 = DIRECTION('',(-2.54877641002E-16,-1.)); +#25609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25610 = PCURVE('',#25009,#25611); +#25611 = DEFINITIONAL_REPRESENTATION('',(#25612),#25616); +#25612 = LINE('',#25613,#25614); +#25613 = CARTESIAN_POINT('',(-0.585371048898,0.)); +#25614 = VECTOR('',#25615,1.); +#25615 = DIRECTION('',(0.,-1.)); +#25616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25617 = ORIENTED_EDGE('',*,*,#25260,.F.); +#25618 = ORIENTED_EDGE('',*,*,#25619,.F.); +#25619 = EDGE_CURVE('',#20533,#25233,#25620,.T.); +#25620 = SURFACE_CURVE('',#25621,(#25625,#25632),.PCURVE_S1.); +#25621 = LINE('',#25622,#25623); +#25622 = CARTESIAN_POINT('',(-22.99999999995,-2.749999999997,19.8)); +#25623 = VECTOR('',#25624,1.); +#25624 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25625 = PCURVE('',#20548,#25626); +#25626 = DEFINITIONAL_REPRESENTATION('',(#25627),#25631); +#25627 = LINE('',#25628,#25629); +#25628 = CARTESIAN_POINT('',(2.749999999997,2.352199804961E-15)); +#25629 = VECTOR('',#25630,1.); +#25630 = DIRECTION('',(-9.860761315263E-31,1.)); +#25631 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25632 = PCURVE('',#20577,#25633); +#25633 = DEFINITIONAL_REPRESENTATION('',(#25634),#25638); +#25634 = LINE('',#25635,#25636); +#25635 = CARTESIAN_POINT('',(-0.785398163398,0.)); +#25636 = VECTOR('',#25637,1.); +#25637 = DIRECTION('',(0.,-1.)); +#25638 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25639 = ORIENTED_EDGE('',*,*,#20532,.T.); +#25640 = ORIENTED_EDGE('',*,*,#23654,.T.); +#25641 = ORIENTED_EDGE('',*,*,#25105,.T.); +#25642 = ORIENTED_EDGE('',*,*,#23604,.T.); +#25643 = ORIENTED_EDGE('',*,*,#23864,.F.); +#25644 = ORIENTED_EDGE('',*,*,#23366,.T.); +#25645 = ORIENTED_EDGE('',*,*,#23484,.T.); +#25646 = ORIENTED_EDGE('',*,*,#24529,.F.); +#25647 = ORIENTED_EDGE('',*,*,#25648,.F.); +#25648 = EDGE_CURVE('',#25649,#24507,#25651,.T.); +#25649 = VERTEX_POINT('',#25650); +#25650 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,19.8)); +#25651 = SURFACE_CURVE('',#25652,(#25656,#25663),.PCURVE_S1.); +#25652 = LINE('',#25653,#25654); +#25653 = CARTESIAN_POINT('',(-22.99999999995,8.06185230375E-15,19.8)); +#25654 = VECTOR('',#25655,1.); +#25655 = DIRECTION('',(-7.197229586486E-13,1.,-8.553453836232E-16)); +#25656 = PCURVE('',#20548,#25657); +#25657 = DEFINITIONAL_REPRESENTATION('',(#25658),#25662); +#25658 = LINE('',#25659,#25660); +#25659 = CARTESIAN_POINT('',(-9.693522803356E-27,-8.291309980896E-42)); +#25660 = VECTOR('',#25661,1.); +#25661 = DIRECTION('',(-1.,-9.860761315263E-31)); +#25662 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25663 = PCURVE('',#21855,#25664); +#25664 = DEFINITIONAL_REPRESENTATION('',(#25665),#25669); +#25665 = LINE('',#25666,#25667); +#25666 = CARTESIAN_POINT('',(23.650000000021,-15.15000000001)); +#25667 = VECTOR('',#25668,1.); +#25668 = DIRECTION('',(-7.579179383562E-13,-1.)); +#25669 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25670 = ORIENTED_EDGE('',*,*,#25671,.T.); +#25671 = EDGE_CURVE('',#25649,#25504,#25672,.T.); +#25672 = SURFACE_CURVE('',#25673,(#25677,#25684),.PCURVE_S1.); +#25673 = LINE('',#25674,#25675); +#25674 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,19.8)); +#25675 = VECTOR('',#25676,1.); +#25676 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25677 = PCURVE('',#20548,#25678); +#25678 = DEFINITIONAL_REPRESENTATION('',(#25679),#25683); +#25679 = LINE('',#25680,#25681); +#25680 = CARTESIAN_POINT('',(30.299999999997,2.591696512378E-14)); +#25681 = VECTOR('',#25682,1.); +#25682 = DIRECTION('',(-9.860761315263E-31,1.)); +#25683 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25684 = PCURVE('',#20990,#25685); +#25685 = DEFINITIONAL_REPRESENTATION('',(#25686),#25690); +#25686 = LINE('',#25687,#25688); +#25687 = CARTESIAN_POINT('',(0.,0.)); +#25688 = VECTOR('',#25689,1.); +#25689 = DIRECTION('',(1.599442196748E-31,1.)); +#25690 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25691 = ORIENTED_EDGE('',*,*,#25503,.F.); +#25692 = ADVANCED_FACE('',(#25693),#21827,.T.); +#25693 = FACE_BOUND('',#25694,.T.); +#25694 = EDGE_LOOP('',(#25695,#25696,#25717,#25718)); +#25695 = ORIENTED_EDGE('',*,*,#25314,.F.); +#25696 = ORIENTED_EDGE('',*,*,#25697,.T.); +#25697 = EDGE_CURVE('',#25315,#21812,#25698,.T.); +#25698 = SURFACE_CURVE('',#25699,(#25703,#25710),.PCURVE_S1.); +#25699 = LINE('',#25700,#25701); +#25700 = CARTESIAN_POINT('',(-58.,-18.30000000002,19.8)); +#25701 = VECTOR('',#25702,1.); +#25702 = DIRECTION('',(-1.,4.036126853609E-14,-2.012869368759E-30)); +#25703 = PCURVE('',#21827,#25704); +#25704 = DEFINITIONAL_REPRESENTATION('',(#25705),#25709); +#25705 = LINE('',#25706,#25707); +#25706 = CARTESIAN_POINT('',(0.,0.)); +#25707 = VECTOR('',#25708,1.); +#25708 = DIRECTION('',(1.,0.)); +#25709 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25710 = PCURVE('',#21855,#25711); +#25711 = DEFINITIONAL_REPRESENTATION('',(#25712),#25716); +#25712 = LINE('',#25713,#25714); +#25713 = CARTESIAN_POINT('',(-11.35000000002,3.150000000016)); +#25714 = VECTOR('',#25715,1.); +#25715 = DIRECTION('',(-1.,-2.166288828537E-15)); +#25716 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25717 = ORIENTED_EDGE('',*,*,#21811,.T.); +#25718 = ORIENTED_EDGE('',*,*,#25074,.F.); +#25719 = ADVANCED_FACE('',(#25720),#25009,.T.); +#25720 = FACE_BOUND('',#25721,.T.); +#25721 = EDGE_LOOP('',(#25722,#25723,#25724,#25746)); +#25722 = ORIENTED_EDGE('',*,*,#25283,.T.); +#25723 = ORIENTED_EDGE('',*,*,#25597,.T.); +#25724 = ORIENTED_EDGE('',*,*,#25725,.F.); +#25725 = EDGE_CURVE('',#24994,#25575,#25726,.T.); +#25726 = SURFACE_CURVE('',#25727,(#25732,#25739),.PCURVE_S1.); +#25727 = CIRCLE('',#25728,0.75); +#25728 = AXIS2_PLACEMENT_3D('',#25729,#25730,#25731); +#25729 = CARTESIAN_POINT('',(-23.74999999995,-3.002845864741,8.5)); +#25730 = DIRECTION('',(4.233634022014E-29,1.110223024625E-15,1.)); +#25731 = DIRECTION('',(0.833507135527,-0.552508692262,6.134078714548E-16 + )); +#25732 = PCURVE('',#25009,#25733); +#25733 = DEFINITIONAL_REPRESENTATION('',(#25734),#25738); +#25734 = LINE('',#25735,#25736); +#25735 = CARTESIAN_POINT('',(6.28318530718,3.65)); +#25736 = VECTOR('',#25737,1.); +#25737 = DIRECTION('',(-1.,0.)); +#25738 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25739 = PCURVE('',#24583,#25740); +#25740 = DEFINITIONAL_REPRESENTATION('',(#25741),#25745); +#25741 = CIRCLE('',#25742,0.75); +#25742 = AXIS2_PLACEMENT_2D('',#25743,#25744); +#25743 = CARTESIAN_POINT('',(16.750000000019,13.897154135272)); +#25744 = DIRECTION('',(0.833507135527,-0.552508692262)); +#25745 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25746 = ORIENTED_EDGE('',*,*,#24993,.T.); +#25747 = ADVANCED_FACE('',(#25748),#20577,.T.); +#25748 = FACE_BOUND('',#25749,.T.); +#25749 = EDGE_LOOP('',(#25750,#25751,#25772,#25773)); +#25750 = ORIENTED_EDGE('',*,*,#25232,.T.); +#25751 = ORIENTED_EDGE('',*,*,#25752,.T.); +#25752 = EDGE_CURVE('',#25210,#20561,#25753,.T.); +#25753 = SURFACE_CURVE('',#25754,(#25758,#25765),.PCURVE_S1.); +#25754 = LINE('',#25755,#25756); +#25755 = CARTESIAN_POINT('',(-23.74999999995,-1.999999999997,19.8)); +#25756 = VECTOR('',#25757,1.); +#25757 = DIRECTION('',(3.266989957043E-29,8.553453836232E-16,1.)); +#25758 = PCURVE('',#20577,#25759); +#25759 = DEFINITIONAL_REPRESENTATION('',(#25760),#25764); +#25760 = LINE('',#25761,#25762); +#25761 = CARTESIAN_POINT('',(0.785398163398,0.)); +#25762 = VECTOR('',#25763,1.); +#25763 = DIRECTION('',(0.,1.)); +#25764 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25765 = PCURVE('',#20430,#25766); +#25766 = DEFINITIONAL_REPRESENTATION('',(#25767),#25771); +#25767 = LINE('',#25768,#25769); +#25768 = CARTESIAN_POINT('',(14.950000000041,5.809812984216E-30)); +#25769 = VECTOR('',#25770,1.); +#25770 = DIRECTION('',(1.599442196756E-31,-1.)); +#25771 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25772 = ORIENTED_EDGE('',*,*,#20560,.F.); +#25773 = ORIENTED_EDGE('',*,*,#25619,.T.); +#25774 = ADVANCED_FACE('',(#25775,#25848),#20430,.T.); +#25775 = FACE_BOUND('',#25776,.T.); +#25776 = EDGE_LOOP('',(#25777,#25778,#25779,#25802,#25825,#25846,#25847) + ); +#25777 = ORIENTED_EDGE('',*,*,#25752,.F.); +#25778 = ORIENTED_EDGE('',*,*,#25209,.F.); +#25779 = ORIENTED_EDGE('',*,*,#25780,.F.); +#25780 = EDGE_CURVE('',#25781,#25182,#25783,.T.); +#25781 = VERTEX_POINT('',#25782); +#25782 = CARTESIAN_POINT('',(-38.7,-1.999999999996,18.3)); +#25783 = SURFACE_CURVE('',#25784,(#25788,#25795),.PCURVE_S1.); +#25784 = LINE('',#25785,#25786); +#25785 = CARTESIAN_POINT('',(-38.7,-1.999999999996,19.8)); +#25786 = VECTOR('',#25787,1.); +#25787 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25788 = PCURVE('',#20430,#25789); +#25789 = DEFINITIONAL_REPRESENTATION('',(#25790),#25794); +#25790 = LINE('',#25791,#25792); +#25791 = CARTESIAN_POINT('',(0.,0.)); +#25792 = VECTOR('',#25793,1.); +#25793 = DIRECTION('',(-1.599442196756E-31,1.)); +#25794 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25795 = PCURVE('',#25197,#25796); +#25796 = DEFINITIONAL_REPRESENTATION('',(#25797),#25801); +#25797 = LINE('',#25798,#25799); +#25798 = CARTESIAN_POINT('',(2.6,-2.22389799742E-15)); +#25799 = VECTOR('',#25800,1.); +#25800 = DIRECTION('',(9.860761315263E-31,1.)); +#25801 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25802 = ORIENTED_EDGE('',*,*,#25803,.T.); +#25803 = EDGE_CURVE('',#25781,#25804,#25806,.T.); +#25804 = VERTEX_POINT('',#25805); +#25805 = CARTESIAN_POINT('',(-36.7,-1.999999999996,18.3)); +#25806 = SURFACE_CURVE('',#25807,(#25811,#25818),.PCURVE_S1.); +#25807 = LINE('',#25808,#25809); +#25808 = CARTESIAN_POINT('',(-37.775,-1.999999999996,18.3)); +#25809 = VECTOR('',#25810,1.); +#25810 = DIRECTION('',(1.,-3.847253546371E-14,2.054325274013E-31)); +#25811 = PCURVE('',#20430,#25812); +#25812 = DEFINITIONAL_REPRESENTATION('',(#25813),#25817); +#25813 = LINE('',#25814,#25815); +#25814 = CARTESIAN_POINT('',(0.925,1.5)); +#25815 = VECTOR('',#25816,1.); +#25816 = DIRECTION('',(1.,1.919177270007E-31)); +#25817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25818 = PCURVE('',#23742,#25819); +#25819 = DEFINITIONAL_REPRESENTATION('',(#25820),#25824); +#25820 = LINE('',#25821,#25822); +#25821 = CARTESIAN_POINT('',(0.925,0.3)); +#25822 = VECTOR('',#25823,1.); +#25823 = DIRECTION('',(-1.,-2.775557561563E-16)); +#25824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25825 = ORIENTED_EDGE('',*,*,#25826,.T.); +#25826 = EDGE_CURVE('',#25804,#20414,#25827,.T.); +#25827 = SURFACE_CURVE('',#25828,(#25832,#25839),.PCURVE_S1.); +#25828 = LINE('',#25829,#25830); +#25829 = CARTESIAN_POINT('',(-36.7,-1.999999999996,19.8)); +#25830 = VECTOR('',#25831,1.); +#25831 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25832 = PCURVE('',#20430,#25833); +#25833 = DEFINITIONAL_REPRESENTATION('',(#25834),#25838); +#25834 = LINE('',#25835,#25836); +#25835 = CARTESIAN_POINT('',(2.,6.997380949134E-31)); +#25836 = VECTOR('',#25837,1.); +#25837 = DIRECTION('',(-1.599442196756E-31,1.)); +#25838 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25839 = PCURVE('',#20460,#25840); +#25840 = DEFINITIONAL_REPRESENTATION('',(#25841),#25845); +#25841 = LINE('',#25842,#25843); +#25842 = CARTESIAN_POINT('',(0.,-0.)); +#25843 = VECTOR('',#25844,1.); +#25844 = DIRECTION('',(9.860761315263E-31,1.)); +#25845 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25846 = ORIENTED_EDGE('',*,*,#20413,.T.); +#25847 = ORIENTED_EDGE('',*,*,#20589,.T.); +#25848 = FACE_BOUND('',#25849,.T.); +#25849 = EDGE_LOOP('',(#25850)); +#25850 = ORIENTED_EDGE('',*,*,#20916,.T.); +#25851 = ADVANCED_FACE('',(#25852,#25899),#21044,.F.); +#25852 = FACE_BOUND('',#25853,.T.); +#25853 = EDGE_LOOP('',(#25854,#25855,#25856,#25877,#25878)); +#25854 = ORIENTED_EDGE('',*,*,#25431,.F.); +#25855 = ORIENTED_EDGE('',*,*,#25549,.F.); +#25856 = ORIENTED_EDGE('',*,*,#25857,.F.); +#25857 = EDGE_CURVE('',#24795,#25527,#25858,.T.); +#25858 = SURFACE_CURVE('',#25859,(#25863,#25870),.PCURVE_S1.); +#25859 = LINE('',#25860,#25861); +#25860 = CARTESIAN_POINT('',(-58.,-30.30000000002,19.8)); +#25861 = VECTOR('',#25862,1.); +#25862 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25863 = PCURVE('',#21044,#25864); +#25864 = DEFINITIONAL_REPRESENTATION('',(#25865),#25869); +#25865 = LINE('',#25866,#25867); +#25866 = CARTESIAN_POINT('',(-3.666538920737E-16,15.3)); +#25867 = VECTOR('',#25868,1.); +#25868 = DIRECTION('',(5.257801617149E-17,-1.)); +#25869 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25870 = PCURVE('',#20990,#25871); +#25871 = DEFINITIONAL_REPRESENTATION('',(#25872),#25876); +#25872 = LINE('',#25873,#25874); +#25873 = CARTESIAN_POINT('',(35.000000000021,2.375779640428E-26)); +#25874 = VECTOR('',#25875,1.); +#25875 = DIRECTION('',(1.599442196748E-31,1.)); +#25876 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25877 = ORIENTED_EDGE('',*,*,#24794,.T.); +#25878 = ORIENTED_EDGE('',*,*,#25879,.T.); +#25879 = EDGE_CURVE('',#24797,#25432,#25880,.T.); +#25880 = SURFACE_CURVE('',#25881,(#25885,#25892),.PCURVE_S1.); +#25881 = LINE('',#25882,#25883); +#25882 = CARTESIAN_POINT('',(-58.,-30.30000000002,8.5)); +#25883 = VECTOR('',#25884,1.); +#25884 = DIRECTION('',(0.921039874882,0.38946828995,-3.857079200482E-16) + ); +#25885 = PCURVE('',#21044,#25886); +#25886 = DEFINITIONAL_REPRESENTATION('',(#25887),#25891); +#25887 = LINE('',#25888,#25889); +#25888 = CARTESIAN_POINT('',(-1.591623590269E-16,4.)); +#25889 = VECTOR('',#25890,1.); +#25890 = DIRECTION('',(1.,-4.930380657631E-32)); +#25891 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25892 = PCURVE('',#24583,#25893); +#25893 = DEFINITIONAL_REPRESENTATION('',(#25894),#25898); +#25894 = LINE('',#25895,#25896); +#25895 = CARTESIAN_POINT('',(-17.50000000002,-13.40000000001)); +#25896 = VECTOR('',#25897,1.); +#25897 = DIRECTION('',(0.921039874882,0.38946828995)); +#25898 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25899 = FACE_BOUND('',#25900,.T.); +#25900 = EDGE_LOOP('',(#25901)); +#25901 = ORIENTED_EDGE('',*,*,#21007,.T.); +#25902 = ADVANCED_FACE('',(#25903),#24583,.F.); +#25903 = FACE_BOUND('',#25904,.T.); +#25904 = EDGE_LOOP('',(#25905,#25906,#25907,#25908,#25909,#25910,#25911) + ); +#25905 = ORIENTED_EDGE('',*,*,#24559,.F.); +#25906 = ORIENTED_EDGE('',*,*,#25021,.T.); +#25907 = ORIENTED_EDGE('',*,*,#25725,.T.); +#25908 = ORIENTED_EDGE('',*,*,#25574,.F.); +#25909 = ORIENTED_EDGE('',*,*,#25454,.T.); +#25910 = ORIENTED_EDGE('',*,*,#25879,.F.); +#25911 = ORIENTED_EDGE('',*,*,#24869,.F.); +#25912 = ADVANCED_FACE('',(#25913),#24856,.T.); +#25913 = FACE_BOUND('',#25914,.T.); +#25914 = EDGE_LOOP('',(#25915,#25916,#25939,#25960)); +#25915 = ORIENTED_EDGE('',*,*,#24842,.F.); +#25916 = ORIENTED_EDGE('',*,*,#25917,.F.); +#25917 = EDGE_CURVE('',#25918,#24795,#25920,.T.); +#25918 = VERTEX_POINT('',#25919); +#25919 = CARTESIAN_POINT('',(-58.,-30.30000000002,19.8)); +#25920 = SURFACE_CURVE('',#25921,(#25925,#25932),.PCURVE_S1.); +#25921 = LINE('',#25922,#25923); +#25922 = CARTESIAN_POINT('',(-58.,-30.30000000002,19.8)); +#25923 = VECTOR('',#25924,1.); +#25924 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#25925 = PCURVE('',#24856,#25926); +#25926 = DEFINITIONAL_REPRESENTATION('',(#25927),#25931); +#25927 = LINE('',#25928,#25929); +#25928 = CARTESIAN_POINT('',(0.,-0.)); +#25929 = VECTOR('',#25930,1.); +#25930 = DIRECTION('',(9.860761315263E-31,1.)); +#25931 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25932 = PCURVE('',#20990,#25933); +#25933 = DEFINITIONAL_REPRESENTATION('',(#25934),#25938); +#25934 = LINE('',#25935,#25936); +#25935 = CARTESIAN_POINT('',(35.000000000021,2.375779640428E-26)); +#25936 = VECTOR('',#25937,1.); +#25937 = DIRECTION('',(1.599442196748E-31,1.)); +#25938 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25939 = ORIENTED_EDGE('',*,*,#25940,.T.); +#25940 = EDGE_CURVE('',#25918,#25338,#25941,.T.); +#25941 = SURFACE_CURVE('',#25942,(#25946,#25953),.PCURVE_S1.); +#25942 = LINE('',#25943,#25944); +#25943 = CARTESIAN_POINT('',(-58.,-30.30000000002,19.8)); +#25944 = VECTOR('',#25945,1.); +#25945 = DIRECTION('',(2.228178302125E-14,1.,-8.553453836232E-16)); +#25946 = PCURVE('',#24856,#25947); +#25947 = DEFINITIONAL_REPRESENTATION('',(#25948),#25952); +#25948 = LINE('',#25949,#25950); +#25949 = CARTESIAN_POINT('',(0.,-0.)); +#25950 = VECTOR('',#25951,1.); +#25951 = DIRECTION('',(1.,0.)); +#25952 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25953 = PCURVE('',#21855,#25954); +#25954 = DEFINITIONAL_REPRESENTATION('',(#25955),#25959); +#25955 = LINE('',#25956,#25957); +#25956 = CARTESIAN_POINT('',(-11.35000000002,15.150000000014)); +#25957 = VECTOR('',#25958,1.); +#25958 = DIRECTION('',(-1.59131966863E-14,-1.)); +#25959 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25960 = ORIENTED_EDGE('',*,*,#25365,.F.); +#25961 = ADVANCED_FACE('',(#25962),#20460,.T.); +#25962 = FACE_BOUND('',#25963,.T.); +#25963 = EDGE_LOOP('',(#25964,#25965,#25966,#25987)); +#25964 = ORIENTED_EDGE('',*,*,#20446,.F.); +#25965 = ORIENTED_EDGE('',*,*,#25826,.F.); +#25966 = ORIENTED_EDGE('',*,*,#25967,.F.); +#25967 = EDGE_CURVE('',#23704,#25804,#25968,.T.); +#25968 = SURFACE_CURVE('',#25969,(#25973,#25980),.PCURVE_S1.); +#25969 = LINE('',#25970,#25971); +#25970 = CARTESIAN_POINT('',(-36.7,2.149999999996,18.3)); +#25971 = VECTOR('',#25972,1.); +#25972 = DIRECTION('',(3.819991382918E-14,-1.,9.705420841629E-16)); +#25973 = PCURVE('',#20460,#25974); +#25974 = DEFINITIONAL_REPRESENTATION('',(#25975),#25979); +#25975 = LINE('',#25976,#25977); +#25976 = CARTESIAN_POINT('',(4.149999999993,1.5)); +#25977 = VECTOR('',#25978,1.); +#25978 = DIRECTION('',(-1.,-1.151967005397E-16)); +#25979 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25980 = PCURVE('',#23742,#25981); +#25981 = DEFINITIONAL_REPRESENTATION('',(#25982),#25986); +#25982 = LINE('',#25983,#25984); +#25983 = CARTESIAN_POINT('',(-0.15,4.449999999993)); +#25984 = VECTOR('',#25985,1.); +#25985 = DIRECTION('',(-7.639489353673E-14,-1.)); +#25986 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#25987 = ORIENTED_EDGE('',*,*,#23703,.T.); +#25988 = ADVANCED_FACE('',(#25989),#26003,.T.); +#25989 = FACE_BOUND('',#25990,.T.); +#25990 = EDGE_LOOP('',(#25991,#26021,#26049,#26077)); +#25991 = ORIENTED_EDGE('',*,*,#25992,.F.); +#25992 = EDGE_CURVE('',#25993,#25995,#25997,.T.); +#25993 = VERTEX_POINT('',#25994); +#25994 = CARTESIAN_POINT('',(-43.44310988842,-4.599999999996,24.5)); +#25995 = VERTEX_POINT('',#25996); +#25996 = CARTESIAN_POINT('',(-45.32310988843,-4.599999999996,19.8)); +#25997 = SURFACE_CURVE('',#25998,(#26002,#26014),.PCURVE_S1.); +#25998 = LINE('',#25999,#26000); +#25999 = CARTESIAN_POINT('',(-43.44310988842,-4.599999999996,24.5)); +#26000 = VECTOR('',#26001,1.); +#26001 = DIRECTION('',(-0.371390676355,1.173105457285E-16, + -0.928476690885)); +#26002 = PCURVE('',#26003,#26008); +#26003 = PLANE('',#26004); +#26004 = AXIS2_PLACEMENT_3D('',#26005,#26006,#26007); +#26005 = CARTESIAN_POINT('',(-45.32310988843,-4.599999999996,19.8)); +#26006 = DIRECTION('',(0.928476690885,-2.943090481719E-15, + -0.371390676355)); +#26007 = DIRECTION('',(0.371390676355,-1.173105457285E-16,0.928476690885 + )); +#26008 = DEFINITIONAL_REPRESENTATION('',(#26009),#26013); +#26009 = LINE('',#26010,#26011); +#26010 = CARTESIAN_POINT('',(5.062054918708,1.046634268996E-15)); +#26011 = VECTOR('',#26012,1.); +#26012 = DIRECTION('',(-1.,3.167148327126E-31)); +#26013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26014 = PCURVE('',#25169,#26015); +#26015 = DEFINITIONAL_REPRESENTATION('',(#26016),#26020); +#26016 = LINE('',#26017,#26018); +#26017 = CARTESIAN_POINT('',(15.856890111574,-4.7)); +#26018 = VECTOR('',#26019,1.); +#26019 = DIRECTION('',(-0.371390676355,0.928476690885)); +#26020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26021 = ORIENTED_EDGE('',*,*,#26022,.T.); +#26022 = EDGE_CURVE('',#25993,#26023,#26025,.T.); +#26023 = VERTEX_POINT('',#26024); +#26024 = CARTESIAN_POINT('',(-43.44310988842,-13.99999999999,24.5)); +#26025 = SURFACE_CURVE('',#26026,(#26030,#26037),.PCURVE_S1.); +#26026 = LINE('',#26027,#26028); +#26027 = CARTESIAN_POINT('',(-43.44310988842,-4.599999999996,24.5)); +#26028 = VECTOR('',#26029,1.); +#26029 = DIRECTION('',(-2.791857193572E-15,-1.,9.448706592555E-16)); +#26030 = PCURVE('',#26003,#26031); +#26031 = DEFINITIONAL_REPRESENTATION('',(#26032),#26036); +#26032 = LINE('',#26033,#26034); +#26033 = CARTESIAN_POINT('',(5.062054918708,1.046634268996E-15)); +#26034 = VECTOR('',#26035,1.); +#26035 = DIRECTION('',(-4.226880265792E-17,1.)); +#26036 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26037 = PCURVE('',#26038,#26043); +#26038 = PLANE('',#26039); +#26039 = AXIS2_PLACEMENT_3D('',#26040,#26041,#26042); +#26040 = CARTESIAN_POINT('',(-43.44310988842,-4.599999999996,24.5)); +#26041 = DIRECTION('',(2.637824207155E-30,9.448706592555E-16,1.)); +#26042 = DIRECTION('',(-1.,2.791730467357E-15,7.286752014489E-44)); +#26043 = DEFINITIONAL_REPRESENTATION('',(#26044),#26048); +#26044 = LINE('',#26045,#26046); +#26045 = CARTESIAN_POINT('',(0.,0.)); +#26046 = VECTOR('',#26047,1.); +#26047 = DIRECTION('',(1.267262150967E-19,1.)); +#26048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26049 = ORIENTED_EDGE('',*,*,#26050,.F.); +#26050 = EDGE_CURVE('',#26051,#26023,#26053,.T.); +#26051 = VERTEX_POINT('',#26052); +#26052 = CARTESIAN_POINT('',(-45.32310988843,-13.99999999999,19.8)); +#26053 = SURFACE_CURVE('',#26054,(#26058,#26065),.PCURVE_S1.); +#26054 = LINE('',#26055,#26056); +#26055 = CARTESIAN_POINT('',(-43.44310988842,-13.99999999999,24.5)); +#26056 = VECTOR('',#26057,1.); +#26057 = DIRECTION('',(0.371390676355,-1.173105457285E-16,0.928476690885 + )); +#26058 = PCURVE('',#26003,#26059); +#26059 = DEFINITIONAL_REPRESENTATION('',(#26060),#26064); +#26060 = LINE('',#26061,#26062); +#26061 = CARTESIAN_POINT('',(5.062054918708,9.4)); +#26062 = VECTOR('',#26063,1.); +#26063 = DIRECTION('',(1.,-3.167148327126E-31)); +#26064 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26065 = PCURVE('',#26066,#26071); +#26066 = PLANE('',#26067); +#26067 = AXIS2_PLACEMENT_3D('',#26068,#26069,#26070); +#26068 = CARTESIAN_POINT('',(-49.,-13.99999999999,22.15)); +#26069 = DIRECTION('',(-2.791857193572E-15,-1.,9.448706592555E-16)); +#26070 = DIRECTION('',(-3.608931565652E-29,-9.448706592555E-16,-1.)); +#26071 = DEFINITIONAL_REPRESENTATION('',(#26072),#26076); +#26072 = LINE('',#26073,#26074); +#26073 = CARTESIAN_POINT('',(-2.35,5.556890111577)); +#26074 = VECTOR('',#26075,1.); +#26075 = DIRECTION('',(-0.928476690885,0.371390676355)); +#26076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26077 = ORIENTED_EDGE('',*,*,#26078,.F.); +#26078 = EDGE_CURVE('',#25995,#26051,#26079,.T.); +#26079 = SURFACE_CURVE('',#26080,(#26084,#26091),.PCURVE_S1.); +#26080 = LINE('',#26081,#26082); +#26081 = CARTESIAN_POINT('',(-45.32310988843,-9.875000000003,19.8)); +#26082 = VECTOR('',#26083,1.); +#26083 = DIRECTION('',(-2.827667303824E-15,-1.,8.553453836232E-16)); +#26084 = PCURVE('',#26003,#26085); +#26085 = DEFINITIONAL_REPRESENTATION('',(#26086),#26090); +#26086 = LINE('',#26087,#26088); +#26087 = CARTESIAN_POINT('',(-5.597303651148E-15,5.275000000007)); +#26088 = VECTOR('',#26089,1.); +#26089 = DIRECTION('',(-1.386904753947E-16,1.)); +#26090 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26091 = PCURVE('',#21855,#26092); +#26092 = DEFINITIONAL_REPRESENTATION('',(#26093),#26097); +#26093 = LINE('',#26094,#26095); +#26094 = CARTESIAN_POINT('',(1.326890111549,-5.275000000007)); +#26095 = VECTOR('',#26096,1.); +#26096 = DIRECTION('',(3.536731240372E-14,1.)); +#26097 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26098 = ADVANCED_FACE('',(#26099),#26113,.T.); +#26099 = FACE_BOUND('',#26100,.T.); +#26100 = EDGE_LOOP('',(#26101,#26131,#26154,#26177)); +#26101 = ORIENTED_EDGE('',*,*,#26102,.T.); +#26102 = EDGE_CURVE('',#26103,#26105,#26107,.T.); +#26103 = VERTEX_POINT('',#26104); +#26104 = CARTESIAN_POINT('',(-54.55689011158,-4.599999999996,24.5)); +#26105 = VERTEX_POINT('',#26106); +#26106 = CARTESIAN_POINT('',(-52.67689011156,-4.599999999996,19.8)); +#26107 = SURFACE_CURVE('',#26108,(#26112,#26124),.PCURVE_S1.); +#26108 = LINE('',#26109,#26110); +#26109 = CARTESIAN_POINT('',(-54.55689011158,-4.599999999996,24.5)); +#26110 = VECTOR('',#26111,1.); +#26111 = DIRECTION('',(0.371390676357,-1.95633478722E-15,-0.928476690884 + )); +#26112 = PCURVE('',#26113,#26118); +#26113 = PLANE('',#26114); +#26114 = AXIS2_PLACEMENT_3D('',#26115,#26116,#26117); +#26115 = CARTESIAN_POINT('',(-54.55689011158,-4.599999999996,24.5)); +#26116 = DIRECTION('',(-0.928476690884,2.241258175298E-15, + -0.371390676357)); +#26117 = DIRECTION('',(0.371390676357,-1.95633478722E-15,-0.928476690884 + )); +#26118 = DEFINITIONAL_REPRESENTATION('',(#26119),#26123); +#26119 = LINE('',#26120,#26121); +#26120 = CARTESIAN_POINT('',(0.,0.)); +#26121 = VECTOR('',#26122,1.); +#26122 = DIRECTION('',(1.,-3.471729858539E-30)); +#26123 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26124 = PCURVE('',#25169,#26125); +#26125 = DEFINITIONAL_REPRESENTATION('',(#26126),#26130); +#26126 = LINE('',#26127,#26128); +#26127 = CARTESIAN_POINT('',(4.74310988842,-4.7)); +#26128 = VECTOR('',#26129,1.); +#26129 = DIRECTION('',(0.371390676357,0.928476690884)); +#26130 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26131 = ORIENTED_EDGE('',*,*,#26132,.F.); +#26132 = EDGE_CURVE('',#26133,#26105,#26135,.T.); +#26133 = VERTEX_POINT('',#26134); +#26134 = CARTESIAN_POINT('',(-52.67689011156,-13.99999999999,19.8)); +#26135 = SURFACE_CURVE('',#26136,(#26140,#26147),.PCURVE_S1.); +#26136 = LINE('',#26137,#26138); +#26137 = CARTESIAN_POINT('',(-52.67689011156,-9.875000000003,19.8)); +#26138 = VECTOR('',#26139,1.); +#26139 = DIRECTION('',(2.756047083318E-15,1.,-8.553453836232E-16)); +#26140 = PCURVE('',#26113,#26141); +#26141 = DEFINITIONAL_REPRESENTATION('',(#26142),#26146); +#26142 = LINE('',#26143,#26144); +#26143 = CARTESIAN_POINT('',(5.062054918712,5.275000000007)); +#26144 = VECTOR('',#26145,1.); +#26145 = DIRECTION('',(-1.385963455254E-16,-1.)); +#26146 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26147 = PCURVE('',#21855,#26148); +#26148 = DEFINITIONAL_REPRESENTATION('',(#26149),#26153); +#26149 = LINE('',#26150,#26151); +#26150 = CARTESIAN_POINT('',(-6.026890111585,-5.275000000007)); +#26151 = VECTOR('',#26152,1.); +#26152 = DIRECTION('',(-3.543893262423E-14,-1.)); +#26153 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26154 = ORIENTED_EDGE('',*,*,#26155,.F.); +#26155 = EDGE_CURVE('',#26156,#26133,#26158,.T.); +#26156 = VERTEX_POINT('',#26157); +#26157 = CARTESIAN_POINT('',(-54.55689011158,-13.99999999999,24.5)); +#26158 = SURFACE_CURVE('',#26159,(#26163,#26170),.PCURVE_S1.); +#26159 = LINE('',#26160,#26161); +#26160 = CARTESIAN_POINT('',(-54.55689011158,-13.99999999999,24.5)); +#26161 = VECTOR('',#26162,1.); +#26162 = DIRECTION('',(0.371390676357,-1.95633478722E-15,-0.928476690884 + )); +#26163 = PCURVE('',#26113,#26164); +#26164 = DEFINITIONAL_REPRESENTATION('',(#26165),#26169); +#26165 = LINE('',#26166,#26167); +#26166 = CARTESIAN_POINT('',(3.150647484167E-14,9.4)); +#26167 = VECTOR('',#26168,1.); +#26168 = DIRECTION('',(1.,-3.471729858539E-30)); +#26169 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26170 = PCURVE('',#26066,#26171); +#26171 = DEFINITIONAL_REPRESENTATION('',(#26172),#26176); +#26172 = LINE('',#26173,#26174); +#26173 = CARTESIAN_POINT('',(-2.35,-5.556890111577)); +#26174 = VECTOR('',#26175,1.); +#26175 = DIRECTION('',(0.928476690884,0.371390676357)); +#26176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26177 = ORIENTED_EDGE('',*,*,#26178,.F.); +#26178 = EDGE_CURVE('',#26103,#26156,#26179,.T.); +#26179 = SURFACE_CURVE('',#26180,(#26184,#26191),.PCURVE_S1.); +#26180 = LINE('',#26181,#26182); +#26181 = CARTESIAN_POINT('',(-54.55689011158,-4.599999999996,24.5)); +#26182 = VECTOR('',#26183,1.); +#26183 = DIRECTION('',(-2.791857193572E-15,-1.,9.448706592555E-16)); +#26184 = PCURVE('',#26113,#26185); +#26185 = DEFINITIONAL_REPRESENTATION('',(#26186),#26190); +#26186 = LINE('',#26187,#26188); +#26187 = CARTESIAN_POINT('',(0.,0.)); +#26188 = VECTOR('',#26189,1.); +#26189 = DIRECTION('',(4.217467278849E-17,1.)); +#26190 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26191 = PCURVE('',#26038,#26192); +#26192 = DEFINITIONAL_REPRESENTATION('',(#26193),#26197); +#26193 = LINE('',#26194,#26195); +#26194 = CARTESIAN_POINT('',(11.113780223153,-3.553604992673E-15)); +#26195 = VECTOR('',#26196,1.); +#26196 = DIRECTION('',(1.267262150967E-19,1.)); +#26197 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26198 = ADVANCED_FACE('',(#26199),#26038,.T.); +#26199 = FACE_BOUND('',#26200,.T.); +#26200 = EDGE_LOOP('',(#26201,#26222,#26223,#26244)); +#26201 = ORIENTED_EDGE('',*,*,#26202,.T.); +#26202 = EDGE_CURVE('',#25993,#26103,#26203,.T.); +#26203 = SURFACE_CURVE('',#26204,(#26208,#26215),.PCURVE_S1.); +#26204 = LINE('',#26205,#26206); +#26205 = CARTESIAN_POINT('',(-43.44310988842,-4.599999999996,24.5)); +#26206 = VECTOR('',#26207,1.); +#26207 = DIRECTION('',(-1.,2.791730467357E-15,2.24207754292E-44)); +#26208 = PCURVE('',#26038,#26209); +#26209 = DEFINITIONAL_REPRESENTATION('',(#26210),#26214); +#26210 = LINE('',#26211,#26212); +#26211 = CARTESIAN_POINT('',(0.,0.)); +#26212 = VECTOR('',#26213,1.); +#26213 = DIRECTION('',(1.,4.766564893681E-59)); +#26214 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26215 = PCURVE('',#25169,#26216); +#26216 = DEFINITIONAL_REPRESENTATION('',(#26217),#26221); +#26217 = LINE('',#26218,#26219); +#26218 = CARTESIAN_POINT('',(15.856890111574,-4.7)); +#26219 = VECTOR('',#26220,1.); +#26220 = DIRECTION('',(-1.,3.012206158318E-29)); +#26221 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26222 = ORIENTED_EDGE('',*,*,#26178,.T.); +#26223 = ORIENTED_EDGE('',*,*,#26224,.F.); +#26224 = EDGE_CURVE('',#26023,#26156,#26225,.T.); +#26225 = SURFACE_CURVE('',#26226,(#26230,#26237),.PCURVE_S1.); +#26226 = LINE('',#26227,#26228); +#26227 = CARTESIAN_POINT('',(-43.44310988842,-13.99999999999,24.5)); +#26228 = VECTOR('',#26229,1.); +#26229 = DIRECTION('',(-1.,2.791730467357E-15,2.24207754292E-44)); +#26230 = PCURVE('',#26038,#26231); +#26231 = DEFINITIONAL_REPRESENTATION('',(#26232),#26236); +#26232 = LINE('',#26233,#26234); +#26233 = CARTESIAN_POINT('',(-1.164542949434E-15,9.4)); +#26234 = VECTOR('',#26235,1.); +#26235 = DIRECTION('',(1.,4.766564893681E-59)); +#26236 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26237 = PCURVE('',#26066,#26238); +#26238 = DEFINITIONAL_REPRESENTATION('',(#26239),#26243); +#26239 = LINE('',#26240,#26241); +#26240 = CARTESIAN_POINT('',(-2.35,5.556890111577)); +#26241 = VECTOR('',#26242,1.); +#26242 = DIRECTION('',(3.345149144937E-29,-1.)); +#26243 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26244 = ORIENTED_EDGE('',*,*,#26022,.F.); +#26245 = ADVANCED_FACE('',(#26246),#26066,.T.); +#26246 = FACE_BOUND('',#26247,.T.); +#26247 = EDGE_LOOP('',(#26248,#26249,#26250,#26271)); +#26248 = ORIENTED_EDGE('',*,*,#26224,.T.); +#26249 = ORIENTED_EDGE('',*,*,#26155,.T.); +#26250 = ORIENTED_EDGE('',*,*,#26251,.F.); +#26251 = EDGE_CURVE('',#26051,#26133,#26252,.T.); +#26252 = SURFACE_CURVE('',#26253,(#26257,#26264),.PCURVE_S1.); +#26253 = LINE('',#26254,#26255); +#26254 = CARTESIAN_POINT('',(-47.82499999999,-13.99999999999,19.8)); +#26255 = VECTOR('',#26256,1.); +#26256 = DIRECTION('',(-1.,2.791857193572E-15,3.01219531885E-29)); +#26257 = PCURVE('',#26066,#26258); +#26258 = DEFINITIONAL_REPRESENTATION('',(#26259),#26263); +#26259 = LINE('',#26260,#26261); +#26260 = CARTESIAN_POINT('',(2.35,1.175000000012)); +#26261 = VECTOR('',#26262,1.); +#26262 = DIRECTION('',(3.329418520983E-30,-1.)); +#26263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26264 = PCURVE('',#21855,#26265); +#26265 = DEFINITIONAL_REPRESENTATION('',(#26266),#26270); +#26266 = LINE('',#26267,#26268); +#26267 = CARTESIAN_POINT('',(-1.175000000012,-1.150000000014)); +#26268 = VECTOR('',#26269,1.); +#26269 = DIRECTION('',(-1.,3.540312251398E-14)); +#26270 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26271 = ORIENTED_EDGE('',*,*,#26050,.T.); +#26272 = ADVANCED_FACE('',(#26273),#24491,.F.); +#26273 = FACE_BOUND('',#26274,.T.); +#26274 = EDGE_LOOP('',(#26275,#26298,#26299,#26322)); +#26275 = ORIENTED_EDGE('',*,*,#26276,.F.); +#26276 = EDGE_CURVE('',#24300,#26277,#26279,.T.); +#26277 = VERTEX_POINT('',#26278); +#26278 = CARTESIAN_POINT('',(-35.,-4.599999999996,19.8)); +#26279 = SURFACE_CURVE('',#26280,(#26284,#26291),.PCURVE_S1.); +#26280 = LINE('',#26281,#26282); +#26281 = CARTESIAN_POINT('',(-35.,-7.575000000005,19.8)); +#26282 = VECTOR('',#26283,1.); +#26283 = DIRECTION('',(-4.929720995381E-14,-1.,8.553453836232E-16)); +#26284 = PCURVE('',#24491,#26285); +#26285 = DEFINITIONAL_REPRESENTATION('',(#26286),#26290); +#26286 = LINE('',#26287,#26288); +#26287 = CARTESIAN_POINT('',(7.575000000005,6.47924128095E-15)); +#26288 = VECTOR('',#26289,1.); +#26289 = DIRECTION('',(1.,0.)); +#26290 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26291 = PCURVE('',#21855,#26292); +#26292 = DEFINITIONAL_REPRESENTATION('',(#26293),#26297); +#26293 = LINE('',#26294,#26295); +#26294 = CARTESIAN_POINT('',(11.649999999978,-7.575000000005)); +#26295 = VECTOR('',#26296,1.); +#26296 = DIRECTION('',(-1.110223024626E-14,1.)); +#26297 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26298 = ORIENTED_EDGE('',*,*,#24477,.T.); +#26299 = ORIENTED_EDGE('',*,*,#26300,.T.); +#26300 = EDGE_CURVE('',#24455,#26301,#26303,.T.); +#26301 = VERTEX_POINT('',#26302); +#26302 = CARTESIAN_POINT('',(-35.,-4.599999999996,18.3)); +#26303 = SURFACE_CURVE('',#26304,(#26308,#26315),.PCURVE_S1.); +#26304 = LINE('',#26305,#26306); +#26305 = CARTESIAN_POINT('',(-35.,-4.599999999996,18.3)); +#26306 = VECTOR('',#26307,1.); +#26307 = DIRECTION('',(-4.929720995381E-14,-1.,8.553453836232E-16)); +#26308 = PCURVE('',#24491,#26309); +#26309 = DEFINITIONAL_REPRESENTATION('',(#26310),#26314); +#26310 = LINE('',#26311,#26312); +#26311 = CARTESIAN_POINT('',(4.599999999996,1.5)); +#26312 = VECTOR('',#26313,1.); +#26313 = DIRECTION('',(1.,0.)); +#26314 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26315 = PCURVE('',#23742,#26316); +#26316 = DEFINITIONAL_REPRESENTATION('',(#26317),#26321); +#26317 = LINE('',#26318,#26319); +#26318 = CARTESIAN_POINT('',(-1.85,-2.3)); +#26319 = VECTOR('',#26320,1.); +#26320 = DIRECTION('',(1.110223024626E-14,-1.)); +#26321 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26322 = ORIENTED_EDGE('',*,*,#26323,.F.); +#26323 = EDGE_CURVE('',#26277,#26301,#26324,.T.); +#26324 = SURFACE_CURVE('',#26325,(#26329,#26336),.PCURVE_S1.); +#26325 = LINE('',#26326,#26327); +#26326 = CARTESIAN_POINT('',(-35.,-4.599999999996,19.8)); +#26327 = VECTOR('',#26328,1.); +#26328 = DIRECTION('',(-2.826996393094E-29,-7.401486830834E-16,-1.)); +#26329 = PCURVE('',#24491,#26330); +#26330 = DEFINITIONAL_REPRESENTATION('',(#26331),#26335); +#26331 = LINE('',#26332,#26333); +#26332 = CARTESIAN_POINT('',(4.599999999996,3.934588764663E-15)); +#26333 = VECTOR('',#26334,1.); +#26334 = DIRECTION('',(-1.151967005397E-16,1.)); +#26335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26336 = PCURVE('',#25169,#26337); +#26337 = DEFINITIONAL_REPRESENTATION('',(#26338),#26342); +#26338 = LINE('',#26339,#26340); +#26339 = CARTESIAN_POINT('',(24.3,-7.322619879413E-28)); +#26340 = VECTOR('',#26341,1.); +#26341 = DIRECTION('',(3.919006132273E-30,1.)); +#26342 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26343 = ADVANCED_FACE('',(#26344),#23742,.F.); +#26344 = FACE_BOUND('',#26345,.T.); +#26345 = EDGE_LOOP('',(#26346,#26347,#26348,#26371,#26392,#26393,#26394, + #26395)); +#26346 = ORIENTED_EDGE('',*,*,#25967,.T.); +#26347 = ORIENTED_EDGE('',*,*,#25803,.F.); +#26348 = ORIENTED_EDGE('',*,*,#26349,.F.); +#26349 = EDGE_CURVE('',#26350,#25781,#26352,.T.); +#26350 = VERTEX_POINT('',#26351); +#26351 = CARTESIAN_POINT('',(-38.7,-4.599999999996,18.3)); +#26352 = SURFACE_CURVE('',#26353,(#26357,#26364),.PCURVE_S1.); +#26353 = LINE('',#26354,#26355); +#26354 = CARTESIAN_POINT('',(-38.7,-3.449999999996,18.3)); +#26355 = VECTOR('',#26356,1.); +#26356 = DIRECTION('',(3.862198856317E-14,1.,-7.401486830834E-16)); +#26357 = PCURVE('',#23742,#26358); +#26358 = DEFINITIONAL_REPRESENTATION('',(#26359),#26363); +#26359 = LINE('',#26360,#26361); +#26360 = CARTESIAN_POINT('',(1.85,-1.15)); +#26361 = VECTOR('',#26362,1.); +#26362 = DIRECTION('',(-4.270088556251E-16,1.)); +#26363 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26364 = PCURVE('',#25197,#26365); +#26365 = DEFINITIONAL_REPRESENTATION('',(#26366),#26370); +#26366 = LINE('',#26367,#26368); +#26367 = CARTESIAN_POINT('',(1.15,1.5)); +#26368 = VECTOR('',#26369,1.); +#26369 = DIRECTION('',(1.,-1.151967005397E-16)); +#26370 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26371 = ORIENTED_EDGE('',*,*,#26372,.F.); +#26372 = EDGE_CURVE('',#26301,#26350,#26373,.T.); +#26373 = SURFACE_CURVE('',#26374,(#26378,#26385),.PCURVE_S1.); +#26374 = LINE('',#26375,#26376); +#26375 = CARTESIAN_POINT('',(-38.7,-4.599999999996,18.3)); +#26376 = VECTOR('',#26377,1.); +#26377 = DIRECTION('',(-1.,3.909516053833E-14,-9.299097377069E-31)); +#26378 = PCURVE('',#23742,#26379); +#26379 = DEFINITIONAL_REPRESENTATION('',(#26380),#26384); +#26380 = LINE('',#26381,#26382); +#26381 = CARTESIAN_POINT('',(1.85,-2.3)); +#26382 = VECTOR('',#26383,1.); +#26383 = DIRECTION('',(1.,9.001808307772E-16)); +#26384 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26385 = PCURVE('',#25169,#26386); +#26386 = DEFINITIONAL_REPRESENTATION('',(#26387),#26391); +#26387 = LINE('',#26388,#26389); +#26388 = CARTESIAN_POINT('',(20.6,1.5)); +#26389 = VECTOR('',#26390,1.); +#26390 = DIRECTION('',(-1.,-3.923635700109E-44)); +#26391 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26392 = ORIENTED_EDGE('',*,*,#26300,.F.); +#26393 = ORIENTED_EDGE('',*,*,#24454,.T.); +#26394 = ORIENTED_EDGE('',*,*,#24228,.T.); +#26395 = ORIENTED_EDGE('',*,*,#23726,.T.); +#26396 = ADVANCED_FACE('',(#26397),#24364,.F.); +#26397 = FACE_BOUND('',#26398,.T.); +#26398 = EDGE_LOOP('',(#26399,#26422,#26445,#26466)); +#26399 = ORIENTED_EDGE('',*,*,#26400,.F.); +#26400 = EDGE_CURVE('',#26401,#24326,#26403,.T.); +#26401 = VERTEX_POINT('',#26402); +#26402 = CARTESIAN_POINT('',(-63.,-4.599999999995,19.8)); +#26403 = SURFACE_CURVE('',#26404,(#26408,#26415),.PCURVE_S1.); +#26404 = LINE('',#26405,#26406); +#26405 = CARTESIAN_POINT('',(-63.,-9.875000000002,19.8)); +#26406 = VECTOR('',#26407,1.); +#26407 = DIRECTION('',(3.722956838179E-14,1.,-8.553453836232E-16)); +#26408 = PCURVE('',#24364,#26409); +#26409 = DEFINITIONAL_REPRESENTATION('',(#26410),#26414); +#26410 = LINE('',#26411,#26412); +#26411 = CARTESIAN_POINT('',(-5.275000000007,4.511946898619E-15)); +#26412 = VECTOR('',#26413,1.); +#26413 = DIRECTION('',(1.,0.)); +#26414 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26415 = PCURVE('',#21855,#26416); +#26416 = DEFINITIONAL_REPRESENTATION('',(#26417),#26421); +#26417 = LINE('',#26418,#26419); +#26418 = CARTESIAN_POINT('',(-16.35000000002,-5.275000000007)); +#26419 = VECTOR('',#26420,1.); +#26420 = DIRECTION('',(-9.654113257621E-16,-1.)); +#26421 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26422 = ORIENTED_EDGE('',*,*,#26423,.T.); +#26423 = EDGE_CURVE('',#26401,#26424,#26426,.T.); +#26424 = VERTEX_POINT('',#26425); +#26425 = CARTESIAN_POINT('',(-63.,-4.599999999995,18.3)); +#26426 = SURFACE_CURVE('',#26427,(#26431,#26438),.PCURVE_S1.); +#26427 = LINE('',#26428,#26429); +#26428 = CARTESIAN_POINT('',(-63.,-4.599999999995,19.8)); +#26429 = VECTOR('',#26430,1.); +#26430 = DIRECTION('',(-2.826996393094E-29,-7.401486830834E-16,-1.)); +#26431 = PCURVE('',#24364,#26432); +#26432 = DEFINITIONAL_REPRESENTATION('',(#26433),#26437); +#26433 = LINE('',#26434,#26435); +#26434 = CARTESIAN_POINT('',(0.,0.)); +#26435 = VECTOR('',#26436,1.); +#26436 = DIRECTION('',(1.151967005397E-16,1.)); +#26437 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26438 = PCURVE('',#25169,#26439); +#26439 = DEFINITIONAL_REPRESENTATION('',(#26440),#26444); +#26440 = LINE('',#26441,#26442); +#26441 = CARTESIAN_POINT('',(-3.7,1.118437044336E-28)); +#26442 = VECTOR('',#26443,1.); +#26443 = DIRECTION('',(3.919006132273E-30,1.)); +#26444 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26445 = ORIENTED_EDGE('',*,*,#26446,.F.); +#26446 = EDGE_CURVE('',#24349,#26424,#26447,.T.); +#26447 = SURFACE_CURVE('',#26448,(#26452,#26459),.PCURVE_S1.); +#26448 = LINE('',#26449,#26450); +#26449 = CARTESIAN_POINT('',(-63.,4.599999999995,18.3)); +#26450 = VECTOR('',#26451,1.); +#26451 = DIRECTION('',(3.723450250342E-14,-1.,8.553453836232E-16)); +#26452 = PCURVE('',#24364,#26453); +#26453 = DEFINITIONAL_REPRESENTATION('',(#26454),#26458); +#26454 = LINE('',#26455,#26456); +#26455 = CARTESIAN_POINT('',(9.199999999989,1.5)); +#26456 = VECTOR('',#26457,1.); +#26457 = DIRECTION('',(-1.,9.860761315263E-31)); +#26458 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26459 = PCURVE('',#24392,#26460); +#26460 = DEFINITIONAL_REPRESENTATION('',(#26461),#26465); +#26461 = LINE('',#26462,#26463); +#26462 = CARTESIAN_POINT('',(1.85,6.89999999999)); +#26463 = VECTOR('',#26464,1.); +#26464 = DIRECTION('',(-7.542948221097E-14,-1.)); +#26465 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26466 = ORIENTED_EDGE('',*,*,#24348,.F.); +#26467 = ADVANCED_FACE('',(#26468),#24392,.F.); +#26468 = FACE_BOUND('',#26469,.T.); +#26469 = EDGE_LOOP('',(#26470,#26471,#26494,#26515)); +#26470 = ORIENTED_EDGE('',*,*,#26446,.T.); +#26471 = ORIENTED_EDGE('',*,*,#26472,.F.); +#26472 = EDGE_CURVE('',#26473,#26424,#26475,.T.); +#26473 = VERTEX_POINT('',#26474); +#26474 = CARTESIAN_POINT('',(-59.3,-4.599999999996,18.3)); +#26475 = SURFACE_CURVE('',#26476,(#26480,#26487),.PCURVE_S1.); +#26476 = LINE('',#26477,#26478); +#26477 = CARTESIAN_POINT('',(-59.3,-4.599999999996,18.3)); +#26478 = VECTOR('',#26479,1.); +#26479 = DIRECTION('',(-1.,4.180712902955E-13,-3.250853928289E-28)); +#26480 = PCURVE('',#24392,#26481); +#26481 = DEFINITIONAL_REPRESENTATION('',(#26482),#26486); +#26482 = LINE('',#26483,#26484); +#26483 = CARTESIAN_POINT('',(-1.85,-2.3)); +#26484 = VECTOR('',#26485,1.); +#26485 = DIRECTION('',(1.,3.79876310588E-13)); +#26486 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26487 = PCURVE('',#25169,#26488); +#26488 = DEFINITIONAL_REPRESENTATION('',(#26489),#26493); +#26489 = LINE('',#26490,#26491); +#26490 = CARTESIAN_POINT('',(1.374079097526E-29,1.5)); +#26491 = VECTOR('',#26492,1.); +#26492 = DIRECTION('',(-1.,-4.484155085839E-43)); +#26493 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26494 = ORIENTED_EDGE('',*,*,#26495,.F.); +#26495 = EDGE_CURVE('',#24377,#26473,#26496,.T.); +#26496 = SURFACE_CURVE('',#26497,(#26501,#26508),.PCURVE_S1.); +#26497 = LINE('',#26498,#26499); +#26498 = CARTESIAN_POINT('',(-59.3,-1.149999999996,18.3)); +#26499 = VECTOR('',#26500,1.); +#26500 = DIRECTION('',(-4.68836816394E-14,-1.,7.401486830834E-16)); +#26501 = PCURVE('',#24392,#26502); +#26502 = DEFINITIONAL_REPRESENTATION('',(#26503),#26507); +#26503 = LINE('',#26504,#26505); +#26504 = CARTESIAN_POINT('',(-1.85,1.15)); +#26505 = VECTOR('',#26506,1.); +#26506 = DIRECTION('',(8.688701931848E-15,-1.)); +#26507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26508 = PCURVE('',#24420,#26509); +#26509 = DEFINITIONAL_REPRESENTATION('',(#26510),#26514); +#26510 = LINE('',#26511,#26512); +#26511 = CARTESIAN_POINT('',(1.15,1.5)); +#26512 = VECTOR('',#26513,1.); +#26513 = DIRECTION('',(1.,1.151967005397E-16)); +#26514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26515 = ORIENTED_EDGE('',*,*,#24376,.T.); +#26516 = ADVANCED_FACE('',(#26517),#25197,.T.); +#26517 = FACE_BOUND('',#26518,.T.); +#26518 = EDGE_LOOP('',(#26519,#26520,#26521,#26522)); +#26519 = ORIENTED_EDGE('',*,*,#26349,.T.); +#26520 = ORIENTED_EDGE('',*,*,#25780,.T.); +#26521 = ORIENTED_EDGE('',*,*,#25181,.F.); +#26522 = ORIENTED_EDGE('',*,*,#26523,.F.); +#26523 = EDGE_CURVE('',#26350,#25154,#26524,.T.); +#26524 = SURFACE_CURVE('',#26525,(#26529,#26536),.PCURVE_S1.); +#26525 = LINE('',#26526,#26527); +#26526 = CARTESIAN_POINT('',(-38.7,-4.599999999996,19.8)); +#26527 = VECTOR('',#26528,1.); +#26528 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#26529 = PCURVE('',#25197,#26530); +#26530 = DEFINITIONAL_REPRESENTATION('',(#26531),#26535); +#26531 = LINE('',#26532,#26533); +#26532 = CARTESIAN_POINT('',(0.,-0.)); +#26533 = VECTOR('',#26534,1.); +#26534 = DIRECTION('',(9.860761315263E-31,1.)); +#26535 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26536 = PCURVE('',#25169,#26537); +#26537 = DEFINITIONAL_REPRESENTATION('',(#26538),#26542); +#26538 = LINE('',#26539,#26540); +#26539 = CARTESIAN_POINT('',(20.6,-6.204182835077E-28)); +#26540 = VECTOR('',#26541,1.); +#26541 = DIRECTION('',(-1.599442196757E-31,1.)); +#26542 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26543 = ADVANCED_FACE('',(#26544,#26576),#21855,.F.); +#26544 = FACE_BOUND('',#26545,.T.); +#26545 = EDGE_LOOP('',(#26546,#26547,#26548,#26549,#26550,#26551,#26552, + #26553,#26554,#26555)); +#26546 = ORIENTED_EDGE('',*,*,#25648,.T.); +#26547 = ORIENTED_EDGE('',*,*,#24506,.T.); +#26548 = ORIENTED_EDGE('',*,*,#23892,.T.); +#26549 = ORIENTED_EDGE('',*,*,#23249,.T.); +#26550 = ORIENTED_EDGE('',*,*,#23531,.T.); +#26551 = ORIENTED_EDGE('',*,*,#21839,.F.); +#26552 = ORIENTED_EDGE('',*,*,#25697,.F.); +#26553 = ORIENTED_EDGE('',*,*,#25337,.F.); +#26554 = ORIENTED_EDGE('',*,*,#25940,.F.); +#26555 = ORIENTED_EDGE('',*,*,#26556,.F.); +#26556 = EDGE_CURVE('',#25649,#25918,#26557,.T.); +#26557 = SURFACE_CURVE('',#26558,(#26562,#26569),.PCURVE_S1.); +#26558 = LINE('',#26559,#26560); +#26559 = CARTESIAN_POINT('',(-22.99999999997,-30.29999999999,19.8)); +#26560 = VECTOR('',#26561,1.); +#26561 = DIRECTION('',(-1.,-7.556262188718E-13,6.788313534074E-28)); +#26562 = PCURVE('',#21855,#26563); +#26563 = DEFINITIONAL_REPRESENTATION('',(#26564),#26568); +#26564 = LINE('',#26565,#26566); +#26565 = CARTESIAN_POINT('',(23.650000000001,15.149999999987)); +#26566 = VECTOR('',#26567,1.); +#26567 = DIRECTION('',(-1.,7.938211985794E-13)); +#26568 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26569 = PCURVE('',#20990,#26570); +#26570 = DEFINITIONAL_REPRESENTATION('',(#26571),#26575); +#26571 = LINE('',#26572,#26573); +#26572 = CARTESIAN_POINT('',(0.,0.)); +#26573 = VECTOR('',#26574,1.); +#26574 = DIRECTION('',(1.,-1.793662034336E-43)); +#26575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26576 = FACE_BOUND('',#26577,.T.); +#26577 = EDGE_LOOP('',(#26578,#26579,#26600,#26601,#26602,#26603,#26624, + #26625,#26626,#26627,#26628,#26629)); +#26578 = ORIENTED_EDGE('',*,*,#26276,.T.); +#26579 = ORIENTED_EDGE('',*,*,#26580,.T.); +#26580 = EDGE_CURVE('',#26277,#25995,#26581,.T.); +#26581 = SURFACE_CURVE('',#26582,(#26586,#26593),.PCURVE_S1.); +#26582 = LINE('',#26583,#26584); +#26583 = CARTESIAN_POINT('',(-52.97499999998,-4.599999999999,19.8)); +#26584 = VECTOR('',#26585,1.); +#26585 = DIRECTION('',(-1.,4.180712902955E-13,-3.250853928289E-28)); +#26586 = PCURVE('',#21855,#26587); +#26587 = DEFINITIONAL_REPRESENTATION('',(#26588),#26592); +#26588 = LINE('',#26589,#26590); +#26589 = CARTESIAN_POINT('',(-6.325000000009,-10.55000000001)); +#26590 = VECTOR('',#26591,1.); +#26591 = DIRECTION('',(-1.,-3.79876310588E-13)); +#26592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26593 = PCURVE('',#25169,#26594); +#26594 = DEFINITIONAL_REPRESENTATION('',(#26595),#26599); +#26595 = LINE('',#26596,#26597); +#26596 = CARTESIAN_POINT('',(6.325000000013,-1.904325792139E-28)); +#26597 = VECTOR('',#26598,1.); +#26598 = DIRECTION('',(-1.,-4.484155085839E-43)); +#26599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26600 = ORIENTED_EDGE('',*,*,#26078,.T.); +#26601 = ORIENTED_EDGE('',*,*,#26251,.T.); +#26602 = ORIENTED_EDGE('',*,*,#26132,.T.); +#26603 = ORIENTED_EDGE('',*,*,#26604,.T.); +#26604 = EDGE_CURVE('',#26105,#26401,#26605,.T.); +#26605 = SURFACE_CURVE('',#26606,(#26610,#26617),.PCURVE_S1.); +#26606 = LINE('',#26607,#26608); +#26607 = CARTESIAN_POINT('',(-52.97499999998,-4.599999999999,19.8)); +#26608 = VECTOR('',#26609,1.); +#26609 = DIRECTION('',(-1.,4.180712902955E-13,-3.250853928289E-28)); +#26610 = PCURVE('',#21855,#26611); +#26611 = DEFINITIONAL_REPRESENTATION('',(#26612),#26616); +#26612 = LINE('',#26613,#26614); +#26613 = CARTESIAN_POINT('',(-6.325000000009,-10.55000000001)); +#26614 = VECTOR('',#26615,1.); +#26615 = DIRECTION('',(-1.,-3.79876310588E-13)); +#26616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26617 = PCURVE('',#25169,#26618); +#26618 = DEFINITIONAL_REPRESENTATION('',(#26619),#26623); +#26619 = LINE('',#26620,#26621); +#26620 = CARTESIAN_POINT('',(6.325000000013,-1.904325792139E-28)); +#26621 = VECTOR('',#26622,1.); +#26622 = DIRECTION('',(-1.,-4.484155085839E-43)); +#26623 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26624 = ORIENTED_EDGE('',*,*,#26400,.T.); +#26625 = ORIENTED_EDGE('',*,*,#24325,.F.); +#26626 = ORIENTED_EDGE('',*,*,#24130,.F.); +#26627 = ORIENTED_EDGE('',*,*,#24203,.F.); +#26628 = ORIENTED_EDGE('',*,*,#23974,.F.); +#26629 = ORIENTED_EDGE('',*,*,#24299,.F.); +#26630 = ADVANCED_FACE('',(#26631),#25169,.T.); +#26631 = FACE_BOUND('',#26632,.T.); +#26632 = EDGE_LOOP('',(#26633,#26634,#26635,#26636,#26637,#26638,#26659, + #26660,#26661,#26662,#26663,#26664)); +#26633 = ORIENTED_EDGE('',*,*,#26580,.F.); +#26634 = ORIENTED_EDGE('',*,*,#26323,.T.); +#26635 = ORIENTED_EDGE('',*,*,#26372,.T.); +#26636 = ORIENTED_EDGE('',*,*,#26523,.T.); +#26637 = ORIENTED_EDGE('',*,*,#25153,.F.); +#26638 = ORIENTED_EDGE('',*,*,#26639,.F.); +#26639 = EDGE_CURVE('',#26473,#25131,#26640,.T.); +#26640 = SURFACE_CURVE('',#26641,(#26645,#26652),.PCURVE_S1.); +#26641 = LINE('',#26642,#26643); +#26642 = CARTESIAN_POINT('',(-59.3,-4.599999999996,19.8)); +#26643 = VECTOR('',#26644,1.); +#26644 = DIRECTION('',(-3.266989957043E-29,-8.553453836232E-16,-1.)); +#26645 = PCURVE('',#25169,#26646); +#26646 = DEFINITIONAL_REPRESENTATION('',(#26647),#26651); +#26647 = LINE('',#26648,#26649); +#26648 = CARTESIAN_POINT('',(0.,0.)); +#26649 = VECTOR('',#26650,1.); +#26650 = DIRECTION('',(-1.599442196757E-31,1.)); +#26651 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26652 = PCURVE('',#24420,#26653); +#26653 = DEFINITIONAL_REPRESENTATION('',(#26654),#26658); +#26654 = LINE('',#26655,#26656); +#26655 = CARTESIAN_POINT('',(4.600000000001,3.934588764667E-15)); +#26656 = VECTOR('',#26657,1.); +#26657 = DIRECTION('',(0.,1.)); +#26658 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26659 = ORIENTED_EDGE('',*,*,#26472,.T.); +#26660 = ORIENTED_EDGE('',*,*,#26423,.F.); +#26661 = ORIENTED_EDGE('',*,*,#26604,.F.); +#26662 = ORIENTED_EDGE('',*,*,#26102,.F.); +#26663 = ORIENTED_EDGE('',*,*,#26202,.F.); +#26664 = ORIENTED_EDGE('',*,*,#25992,.T.); +#26665 = ADVANCED_FACE('',(#26666),#24420,.T.); +#26666 = FACE_BOUND('',#26667,.T.); +#26667 = EDGE_LOOP('',(#26668,#26669,#26670,#26671)); +#26668 = ORIENTED_EDGE('',*,*,#26495,.T.); +#26669 = ORIENTED_EDGE('',*,*,#26639,.T.); +#26670 = ORIENTED_EDGE('',*,*,#25130,.T.); +#26671 = ORIENTED_EDGE('',*,*,#24404,.F.); +#26672 = ADVANCED_FACE('',(#26673,#26680),#20990,.T.); +#26673 = FACE_BOUND('',#26674,.T.); +#26674 = EDGE_LOOP('',(#26675,#26676,#26677,#26678,#26679)); +#26675 = ORIENTED_EDGE('',*,*,#26556,.T.); +#26676 = ORIENTED_EDGE('',*,*,#25917,.T.); +#26677 = ORIENTED_EDGE('',*,*,#25857,.T.); +#26678 = ORIENTED_EDGE('',*,*,#25526,.F.); +#26679 = ORIENTED_EDGE('',*,*,#25671,.F.); +#26680 = FACE_BOUND('',#26681,.T.); +#26681 = EDGE_LOOP('',(#26682)); +#26682 = ORIENTED_EDGE('',*,*,#20975,.T.); +#26683 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#26687)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#26684,#26685,#26686)) +REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#26684 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#26685 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#26686 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#26687 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(2.E-05),#26684, + 'distance_accuracy_value','confusion accuracy'); +#26688 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#26689,#26691); +#26689 = ( REPRESENTATION_RELATIONSHIP('','',#20342,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#26690) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#26690 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#26691 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item', + #26692); +#26692 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','Chair','',#5,#20337,$); +#26693 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#20339)); +#26694 = SHAPE_DEFINITION_REPRESENTATION(#26695,#26701); +#26695 = PRODUCT_DEFINITION_SHAPE('','',#26696); +#26696 = PRODUCT_DEFINITION('design','',#26697,#26700); +#26697 = PRODUCT_DEFINITION_FORMATION('','',#26698); +#26698 = PRODUCT('DeskTop','DeskTop','',(#26699)); +#26699 = PRODUCT_CONTEXT('',#2,'mechanical'); +#26700 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#26701 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#26702),#30102); +#26702 = MANIFOLD_SOLID_BREP('',#26703); +#26703 = CLOSED_SHELL('',(#26704,#26826,#26902,#26980,#27056,#27134, + #27210,#27283,#27330,#27372,#27427,#27514,#27553,#27644,#27679, + #27738,#27773,#27823,#27873,#27955,#28065,#28141,#28212,#28259, + #28341,#28432,#28467,#28558,#28593,#28684,#28719,#28810,#28845, + #28895,#28945,#28995,#29045,#29161,#29237,#29549,#29625,#29674, + #29728,#29804,#29853,#29907,#29961,#29993,#30020,#30047)); +#26704 = ADVANCED_FACE('',(#26705),#26719,.F.); +#26705 = FACE_BOUND('',#26706,.F.); +#26706 = EDGE_LOOP('',(#26707,#26742,#26771,#26799)); +#26707 = ORIENTED_EDGE('',*,*,#26708,.F.); +#26708 = EDGE_CURVE('',#26709,#26711,#26713,.T.); +#26709 = VERTEX_POINT('',#26710); +#26710 = CARTESIAN_POINT('',(14.62992,-16.36372881355,43.5)); +#26711 = VERTEX_POINT('',#26712); +#26712 = CARTESIAN_POINT('',(14.62992,-16.36372881355,42.5)); +#26713 = SURFACE_CURVE('',#26714,(#26718,#26730),.PCURVE_S1.); +#26714 = LINE('',#26715,#26716); +#26715 = CARTESIAN_POINT('',(14.62992,-16.36372881355,43.5)); +#26716 = VECTOR('',#26717,1.); +#26717 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#26718 = PCURVE('',#26719,#26724); +#26719 = CYLINDRICAL_SURFACE('',#26720,4.3); +#26720 = AXIS2_PLACEMENT_3D('',#26721,#26722,#26723); +#26721 = CARTESIAN_POINT('',(10.32992,-16.36372881355,43.5)); +#26722 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#26723 = DIRECTION('',(0.707106781187,-0.707106781187,1.209641042034E-15 + )); +#26724 = DEFINITIONAL_REPRESENTATION('',(#26725),#26729); +#26725 = LINE('',#26726,#26727); +#26726 = CARTESIAN_POINT('',(5.497787143782,0.)); +#26727 = VECTOR('',#26728,1.); +#26728 = DIRECTION('',(0.,1.)); +#26729 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26730 = PCURVE('',#26731,#26736); +#26731 = PLANE('',#26732); +#26732 = AXIS2_PLACEMENT_3D('',#26733,#26734,#26735); +#26733 = CARTESIAN_POINT('',(14.62992,20.663728813559,43.5)); +#26734 = DIRECTION('',(1.,-1.726589343463E-30,2.953660448682E-45)); +#26735 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#26736 = DEFINITIONAL_REPRESENTATION('',(#26737),#26741); +#26737 = LINE('',#26738,#26739); +#26738 = CARTESIAN_POINT('',(37.027457627119,6.334252989737E-14)); +#26739 = VECTOR('',#26740,1.); +#26740 = DIRECTION('',(-1.991873785683E-29,1.)); +#26741 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26742 = ORIENTED_EDGE('',*,*,#26743,.F.); +#26743 = EDGE_CURVE('',#26744,#26709,#26746,.T.); +#26744 = VERTEX_POINT('',#26745); +#26745 = CARTESIAN_POINT('',(10.32992,-20.66372881355,43.5)); +#26746 = SURFACE_CURVE('',#26747,(#26752,#26759),.PCURVE_S1.); +#26747 = CIRCLE('',#26748,4.3); +#26748 = AXIS2_PLACEMENT_3D('',#26749,#26750,#26751); +#26749 = CARTESIAN_POINT('',(10.32992,-16.36372881355,43.5)); +#26750 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#26751 = DIRECTION('',(0.707106781187,-0.707106781187,2.020011343289E-15 + )); +#26752 = PCURVE('',#26719,#26753); +#26753 = DEFINITIONAL_REPRESENTATION('',(#26754),#26758); +#26754 = LINE('',#26755,#26756); +#26755 = CARTESIAN_POINT('',(12.566370614359,2.48689957516E-14)); +#26756 = VECTOR('',#26757,1.); +#26757 = DIRECTION('',(-1.,-4.52345554697E-15)); +#26758 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26759 = PCURVE('',#26760,#26765); +#26760 = PLANE('',#26761); +#26761 = AXIS2_PLACEMENT_3D('',#26762,#26763,#26764); +#26762 = CARTESIAN_POINT('',(-2.000000000036,-8.231057174929E-11,43.5)); +#26763 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#26764 = DIRECTION('',(-1.,1.45092644297E-114,-1.146036670579E-15)); +#26765 = DEFINITIONAL_REPRESENTATION('',(#26766),#26770); +#26766 = CIRCLE('',#26767,4.3); +#26767 = AXIS2_PLACEMENT_2D('',#26768,#26769); +#26768 = CARTESIAN_POINT('',(-12.32992000003,16.363728813477)); +#26769 = DIRECTION('',(-0.707106781187,0.707106781187)); +#26770 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26771 = ORIENTED_EDGE('',*,*,#26772,.F.); +#26772 = EDGE_CURVE('',#26773,#26744,#26775,.T.); +#26773 = VERTEX_POINT('',#26774); +#26774 = CARTESIAN_POINT('',(10.32992,-20.66372881355,42.5)); +#26775 = SURFACE_CURVE('',#26776,(#26780,#26787),.PCURVE_S1.); +#26776 = LINE('',#26777,#26778); +#26777 = CARTESIAN_POINT('',(10.32992,-20.66372881355,43.5)); +#26778 = VECTOR('',#26779,1.); +#26779 = DIRECTION('',(7.91599702251E-57,1.710690767248E-15,1.)); +#26780 = PCURVE('',#26719,#26781); +#26781 = DEFINITIONAL_REPRESENTATION('',(#26782),#26786); +#26782 = LINE('',#26783,#26784); +#26783 = CARTESIAN_POINT('',(7.068583470577,7.105427357601E-15)); +#26784 = VECTOR('',#26785,1.); +#26785 = DIRECTION('',(0.,-1.)); +#26786 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26787 = PCURVE('',#26788,#26793); +#26788 = PLANE('',#26789); +#26789 = AXIS2_PLACEMENT_3D('',#26790,#26791,#26792); +#26790 = CARTESIAN_POINT('',(14.62992,-20.66372881355,43.5)); +#26791 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#26792 = DIRECTION('',(-1.,-8.276528257808E-45,-1.009293658748E-15)); +#26793 = DEFINITIONAL_REPRESENTATION('',(#26794),#26798); +#26794 = LINE('',#26795,#26796); +#26795 = CARTESIAN_POINT('',(4.3,-4.339962732618E-15)); +#26796 = VECTOR('',#26797,1.); +#26797 = DIRECTION('',(-1.009293658748E-15,-1.)); +#26798 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26799 = ORIENTED_EDGE('',*,*,#26800,.T.); +#26800 = EDGE_CURVE('',#26773,#26711,#26801,.T.); +#26801 = SURFACE_CURVE('',#26802,(#26807,#26814),.PCURVE_S1.); +#26802 = CIRCLE('',#26803,4.3); +#26803 = AXIS2_PLACEMENT_3D('',#26804,#26805,#26806); +#26804 = CARTESIAN_POINT('',(10.32992,-16.36372881355,42.5)); +#26805 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#26806 = DIRECTION('',(0.707106781187,-0.707106781187,1.923319432344E-15 + )); +#26807 = PCURVE('',#26719,#26808); +#26808 = DEFINITIONAL_REPRESENTATION('',(#26809),#26813); +#26809 = LINE('',#26810,#26811); +#26810 = CARTESIAN_POINT('',(12.566370614359,1.)); +#26811 = VECTOR('',#26812,1.); +#26812 = DIRECTION('',(-1.,-4.52345554697E-15)); +#26813 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26814 = PCURVE('',#26815,#26820); +#26815 = PLANE('',#26816); +#26816 = AXIS2_PLACEMENT_3D('',#26817,#26818,#26819); +#26817 = CARTESIAN_POINT('',(0.,1.715370661502E-14,42.5)); +#26818 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#26819 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#26820 = DEFINITIONAL_REPRESENTATION('',(#26821),#26825); +#26821 = CIRCLE('',#26822,4.3); +#26822 = AXIS2_PLACEMENT_2D('',#26823,#26824); +#26823 = CARTESIAN_POINT('',(-10.32992,16.363728813559)); +#26824 = DIRECTION('',(-0.707106781187,0.707106781187)); +#26825 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26826 = ADVANCED_FACE('',(#26827),#26731,.F.); +#26827 = FACE_BOUND('',#26828,.T.); +#26828 = EDGE_LOOP('',(#26829,#26830,#26853,#26881)); +#26829 = ORIENTED_EDGE('',*,*,#26708,.F.); +#26830 = ORIENTED_EDGE('',*,*,#26831,.F.); +#26831 = EDGE_CURVE('',#26832,#26709,#26834,.T.); +#26832 = VERTEX_POINT('',#26833); +#26833 = CARTESIAN_POINT('',(14.62992,16.363728813559,43.5)); +#26834 = SURFACE_CURVE('',#26835,(#26839,#26846),.PCURVE_S1.); +#26835 = LINE('',#26836,#26837); +#26836 = CARTESIAN_POINT('',(14.62992,10.331864406739,43.5)); +#26837 = VECTOR('',#26838,1.); +#26838 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#26839 = PCURVE('',#26731,#26840); +#26840 = DEFINITIONAL_REPRESENTATION('',(#26841),#26845); +#26841 = LINE('',#26842,#26843); +#26842 = CARTESIAN_POINT('',(10.331864406821,1.76746250492E-14)); +#26843 = VECTOR('',#26844,1.); +#26844 = DIRECTION('',(1.,-8.006938187993E-29)); +#26845 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26846 = PCURVE('',#26760,#26847); +#26847 = DEFINITIONAL_REPRESENTATION('',(#26848),#26852); +#26848 = LINE('',#26849,#26850); +#26849 = CARTESIAN_POINT('',(-16.62992000003,-10.33186440682)); +#26850 = VECTOR('',#26851,1.); +#26851 = DIRECTION('',(-2.339250078244E-31,1.)); +#26852 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26853 = ORIENTED_EDGE('',*,*,#26854,.F.); +#26854 = EDGE_CURVE('',#26855,#26832,#26857,.T.); +#26855 = VERTEX_POINT('',#26856); +#26856 = CARTESIAN_POINT('',(14.62992,16.363728813559,42.5)); +#26857 = SURFACE_CURVE('',#26858,(#26862,#26869),.PCURVE_S1.); +#26858 = LINE('',#26859,#26860); +#26859 = CARTESIAN_POINT('',(14.62992,16.363728813559,43.5)); +#26860 = VECTOR('',#26861,1.); +#26861 = DIRECTION('',(7.91599702251E-57,1.710690767248E-15,1.)); +#26862 = PCURVE('',#26731,#26863); +#26863 = DEFINITIONAL_REPRESENTATION('',(#26864),#26868); +#26864 = LINE('',#26865,#26866); +#26865 = CARTESIAN_POINT('',(4.3,7.355970299166E-15)); +#26866 = VECTOR('',#26867,1.); +#26867 = DIRECTION('',(1.991873785683E-29,-1.)); +#26868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26869 = PCURVE('',#26870,#26875); +#26870 = CYLINDRICAL_SURFACE('',#26871,4.3); +#26871 = AXIS2_PLACEMENT_3D('',#26872,#26873,#26874); +#26872 = CARTESIAN_POINT('',(10.32992,16.363728813559,43.5)); +#26873 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#26874 = DIRECTION('',(0.707106781187,0.707106781187,-1.209641042034E-15 + )); +#26875 = DEFINITIONAL_REPRESENTATION('',(#26876),#26880); +#26876 = LINE('',#26877,#26878); +#26877 = CARTESIAN_POINT('',(0.785398163397,0.)); +#26878 = VECTOR('',#26879,1.); +#26879 = DIRECTION('',(0.,-1.)); +#26880 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26881 = ORIENTED_EDGE('',*,*,#26882,.T.); +#26882 = EDGE_CURVE('',#26855,#26711,#26883,.T.); +#26883 = SURFACE_CURVE('',#26884,(#26888,#26895),.PCURVE_S1.); +#26884 = LINE('',#26885,#26886); +#26885 = CARTESIAN_POINT('',(14.62992,20.663728813559,42.5)); +#26886 = VECTOR('',#26887,1.); +#26887 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#26888 = PCURVE('',#26731,#26889); +#26889 = DEFINITIONAL_REPRESENTATION('',(#26890),#26894); +#26890 = LINE('',#26891,#26892); +#26891 = CARTESIAN_POINT('',(-1.710690767248E-15,1.)); +#26892 = VECTOR('',#26893,1.); +#26893 = DIRECTION('',(1.,0.)); +#26894 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26895 = PCURVE('',#26815,#26896); +#26896 = DEFINITIONAL_REPRESENTATION('',(#26897),#26901); +#26897 = LINE('',#26898,#26899); +#26898 = CARTESIAN_POINT('',(-14.62992,-20.66372881355)); +#26899 = VECTOR('',#26900,1.); +#26900 = DIRECTION('',(1.747532916004E-45,1.)); +#26901 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26902 = ADVANCED_FACE('',(#26903),#26870,.F.); +#26903 = FACE_BOUND('',#26904,.F.); +#26904 = EDGE_LOOP('',(#26905,#26935,#26957,#26958)); +#26905 = ORIENTED_EDGE('',*,*,#26906,.F.); +#26906 = EDGE_CURVE('',#26907,#26909,#26911,.T.); +#26907 = VERTEX_POINT('',#26908); +#26908 = CARTESIAN_POINT('',(10.32992,20.663728813559,43.5)); +#26909 = VERTEX_POINT('',#26910); +#26910 = CARTESIAN_POINT('',(10.32992,20.663728813559,42.5)); +#26911 = SURFACE_CURVE('',#26912,(#26916,#26923),.PCURVE_S1.); +#26912 = LINE('',#26913,#26914); +#26913 = CARTESIAN_POINT('',(10.32992,20.663728813559,43.5)); +#26914 = VECTOR('',#26915,1.); +#26915 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#26916 = PCURVE('',#26870,#26917); +#26917 = DEFINITIONAL_REPRESENTATION('',(#26918),#26922); +#26918 = LINE('',#26919,#26920); +#26919 = CARTESIAN_POINT('',(-0.785398163397,9.237055564881E-14)); +#26920 = VECTOR('',#26921,1.); +#26921 = DIRECTION('',(0.,1.)); +#26922 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26923 = PCURVE('',#26924,#26929); +#26924 = PLANE('',#26925); +#26925 = AXIS2_PLACEMENT_3D('',#26926,#26927,#26928); +#26926 = CARTESIAN_POINT('',(-14.62992,20.663728813559,43.5)); +#26927 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#26928 = DIRECTION('',(1.,8.276528257808E-45,1.009293658748E-15)); +#26929 = DEFINITIONAL_REPRESENTATION('',(#26930),#26934); +#26930 = LINE('',#26931,#26932); +#26931 = CARTESIAN_POINT('',(24.95984,2.519180823538E-14)); +#26932 = VECTOR('',#26933,1.); +#26933 = DIRECTION('',(-1.009293658748E-15,1.)); +#26934 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26935 = ORIENTED_EDGE('',*,*,#26936,.F.); +#26936 = EDGE_CURVE('',#26832,#26907,#26937,.T.); +#26937 = SURFACE_CURVE('',#26938,(#26943,#26950),.PCURVE_S1.); +#26938 = CIRCLE('',#26939,4.3); +#26939 = AXIS2_PLACEMENT_3D('',#26940,#26941,#26942); +#26940 = CARTESIAN_POINT('',(10.32992,16.363728813559,43.5)); +#26941 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#26942 = DIRECTION('',(0.707106781187,0.707106781187,-3.992707407793E-16 + )); +#26943 = PCURVE('',#26870,#26944); +#26944 = DEFINITIONAL_REPRESENTATION('',(#26945),#26949); +#26945 = LINE('',#26946,#26947); +#26946 = CARTESIAN_POINT('',(6.28318530718,-3.19744231092E-14)); +#26947 = VECTOR('',#26948,1.); +#26948 = DIRECTION('',(-1.,4.52345554697E-15)); +#26949 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26950 = PCURVE('',#26760,#26951); +#26951 = DEFINITIONAL_REPRESENTATION('',(#26952),#26956); +#26952 = CIRCLE('',#26953,4.3); +#26953 = AXIS2_PLACEMENT_2D('',#26954,#26955); +#26954 = CARTESIAN_POINT('',(-12.32992000003,-16.36372881364)); +#26955 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#26956 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26957 = ORIENTED_EDGE('',*,*,#26854,.F.); +#26958 = ORIENTED_EDGE('',*,*,#26959,.T.); +#26959 = EDGE_CURVE('',#26855,#26909,#26960,.T.); +#26960 = SURFACE_CURVE('',#26961,(#26966,#26973),.PCURVE_S1.); +#26961 = CIRCLE('',#26962,4.3); +#26962 = AXIS2_PLACEMENT_3D('',#26963,#26964,#26965); +#26963 = CARTESIAN_POINT('',(10.32992,16.363728813559,42.5)); +#26964 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#26965 = DIRECTION('',(0.707106781187,0.707106781187,-4.959626517245E-16 + )); +#26966 = PCURVE('',#26870,#26967); +#26967 = DEFINITIONAL_REPRESENTATION('',(#26968),#26972); +#26968 = LINE('',#26969,#26970); +#26969 = CARTESIAN_POINT('',(6.28318530718,1.)); +#26970 = VECTOR('',#26971,1.); +#26971 = DIRECTION('',(-1.,4.52345554697E-15)); +#26972 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26973 = PCURVE('',#26815,#26974); +#26974 = DEFINITIONAL_REPRESENTATION('',(#26975),#26979); +#26975 = CIRCLE('',#26976,4.3); +#26976 = AXIS2_PLACEMENT_2D('',#26977,#26978); +#26977 = CARTESIAN_POINT('',(-10.32992,-16.36372881355)); +#26978 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#26979 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#26980 = ADVANCED_FACE('',(#26981),#26924,.F.); +#26981 = FACE_BOUND('',#26982,.T.); +#26982 = EDGE_LOOP('',(#26983,#26984,#27007,#27035)); +#26983 = ORIENTED_EDGE('',*,*,#26906,.F.); +#26984 = ORIENTED_EDGE('',*,*,#26985,.F.); +#26985 = EDGE_CURVE('',#26986,#26907,#26988,.T.); +#26986 = VERTEX_POINT('',#26987); +#26987 = CARTESIAN_POINT('',(-10.32992,20.663728813559,43.5)); +#26988 = SURFACE_CURVE('',#26989,(#26993,#27000),.PCURVE_S1.); +#26989 = LINE('',#26990,#26991); +#26990 = CARTESIAN_POINT('',(-8.314960000018,20.663728813559,43.5)); +#26991 = VECTOR('',#26992,1.); +#26992 = DIRECTION('',(1.,2.339250078243E-31,1.146036670579E-15)); +#26993 = PCURVE('',#26924,#26994); +#26994 = DEFINITIONAL_REPRESENTATION('',(#26995),#26999); +#26995 = LINE('',#26996,#26997); +#26996 = CARTESIAN_POINT('',(6.314959999982,6.373649083232E-15)); +#26997 = VECTOR('',#26998,1.); +#26998 = DIRECTION('',(1.,-1.367430118306E-16)); +#26999 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27000 = PCURVE('',#26760,#27001); +#27001 = DEFINITIONAL_REPRESENTATION('',(#27002),#27006); +#27002 = LINE('',#27003,#27004); +#27003 = CARTESIAN_POINT('',(6.314959999982,-20.66372881364)); +#27004 = VECTOR('',#27005,1.); +#27005 = DIRECTION('',(-1.,-2.339250078243E-31)); +#27006 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27007 = ORIENTED_EDGE('',*,*,#27008,.F.); +#27008 = EDGE_CURVE('',#27009,#26986,#27011,.T.); +#27009 = VERTEX_POINT('',#27010); +#27010 = CARTESIAN_POINT('',(-10.32992,20.663728813559,42.5)); +#27011 = SURFACE_CURVE('',#27012,(#27016,#27023),.PCURVE_S1.); +#27012 = LINE('',#27013,#27014); +#27013 = CARTESIAN_POINT('',(-10.32992,20.663728813559,43.5)); +#27014 = VECTOR('',#27015,1.); +#27015 = DIRECTION('',(7.91599702251E-57,1.710690767248E-15,1.)); +#27016 = PCURVE('',#26924,#27017); +#27017 = DEFINITIONAL_REPRESENTATION('',(#27018),#27022); +#27018 = LINE('',#27019,#27020); +#27019 = CARTESIAN_POINT('',(4.3,4.339962732618E-15)); +#27020 = VECTOR('',#27021,1.); +#27021 = DIRECTION('',(1.009293658748E-15,-1.)); +#27022 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27023 = PCURVE('',#27024,#27029); +#27024 = CYLINDRICAL_SURFACE('',#27025,4.3); +#27025 = AXIS2_PLACEMENT_3D('',#27026,#27027,#27028); +#27026 = CARTESIAN_POINT('',(-10.32992,16.363728813559,43.5)); +#27027 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27028 = DIRECTION('',(-0.707106781187,0.707106781187, + -1.209641042034E-15)); +#27029 = DEFINITIONAL_REPRESENTATION('',(#27030),#27034); +#27030 = LINE('',#27031,#27032); +#27031 = CARTESIAN_POINT('',(0.785398163397,-7.105427357601E-15)); +#27032 = VECTOR('',#27033,1.); +#27033 = DIRECTION('',(0.,-1.)); +#27034 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27035 = ORIENTED_EDGE('',*,*,#27036,.T.); +#27036 = EDGE_CURVE('',#27009,#26909,#27037,.T.); +#27037 = SURFACE_CURVE('',#27038,(#27042,#27049),.PCURVE_S1.); +#27038 = LINE('',#27039,#27040); +#27039 = CARTESIAN_POINT('',(-14.62992,20.663728813559,42.5)); +#27040 = VECTOR('',#27041,1.); +#27041 = DIRECTION('',(1.,-1.277804537842E-114,1.009293658748E-15)); +#27042 = PCURVE('',#26924,#27043); +#27043 = DEFINITIONAL_REPRESENTATION('',(#27044),#27048); +#27044 = LINE('',#27045,#27046); +#27045 = CARTESIAN_POINT('',(-1.009293658748E-15,1.)); +#27046 = VECTOR('',#27047,1.); +#27047 = DIRECTION('',(1.,0.)); +#27048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27049 = PCURVE('',#26815,#27050); +#27050 = DEFINITIONAL_REPRESENTATION('',(#27051),#27055); +#27051 = LINE('',#27052,#27053); +#27052 = CARTESIAN_POINT('',(14.62992,-20.66372881355)); +#27053 = VECTOR('',#27054,1.); +#27054 = DIRECTION('',(-1.,4.090164401715E-48)); +#27055 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27056 = ADVANCED_FACE('',(#27057),#27024,.F.); +#27057 = FACE_BOUND('',#27058,.F.); +#27058 = EDGE_LOOP('',(#27059,#27089,#27111,#27112)); +#27059 = ORIENTED_EDGE('',*,*,#27060,.F.); +#27060 = EDGE_CURVE('',#27061,#27063,#27065,.T.); +#27061 = VERTEX_POINT('',#27062); +#27062 = CARTESIAN_POINT('',(-14.62992,16.363728813559,43.5)); +#27063 = VERTEX_POINT('',#27064); +#27064 = CARTESIAN_POINT('',(-14.62992,16.363728813559,42.5)); +#27065 = SURFACE_CURVE('',#27066,(#27070,#27077),.PCURVE_S1.); +#27066 = LINE('',#27067,#27068); +#27067 = CARTESIAN_POINT('',(-14.62992,16.363728813559,43.5)); +#27068 = VECTOR('',#27069,1.); +#27069 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27070 = PCURVE('',#27024,#27071); +#27071 = DEFINITIONAL_REPRESENTATION('',(#27072),#27076); +#27072 = LINE('',#27073,#27074); +#27073 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#27074 = VECTOR('',#27075,1.); +#27075 = DIRECTION('',(0.,1.)); +#27076 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27077 = PCURVE('',#27078,#27083); +#27078 = PLANE('',#27079); +#27079 = AXIS2_PLACEMENT_3D('',#27080,#27081,#27082); +#27080 = CARTESIAN_POINT('',(-14.62992,-20.66372881355,43.5)); +#27081 = DIRECTION('',(-1.,1.726589343463E-30,-2.953660448682E-45)); +#27082 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#27083 = DEFINITIONAL_REPRESENTATION('',(#27084),#27088); +#27084 = LINE('',#27085,#27086); +#27085 = CARTESIAN_POINT('',(37.027457627119,3.613345310904E-14)); +#27086 = VECTOR('',#27087,1.); +#27087 = DIRECTION('',(1.991873785683E-29,1.)); +#27088 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27089 = ORIENTED_EDGE('',*,*,#27090,.F.); +#27090 = EDGE_CURVE('',#26986,#27061,#27091,.T.); +#27091 = SURFACE_CURVE('',#27092,(#27097,#27104),.PCURVE_S1.); +#27092 = CIRCLE('',#27093,4.3); +#27093 = AXIS2_PLACEMENT_3D('',#27094,#27095,#27096); +#27094 = CARTESIAN_POINT('',(-10.32992,16.363728813559,43.5)); +#27095 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27096 = DIRECTION('',(-0.707106781187,0.707106781187, + -2.020011343289E-15)); +#27097 = PCURVE('',#27024,#27098); +#27098 = DEFINITIONAL_REPRESENTATION('',(#27099),#27103); +#27099 = LINE('',#27100,#27101); +#27100 = CARTESIAN_POINT('',(6.28318530718,-1.24344978758E-13)); +#27101 = VECTOR('',#27102,1.); +#27102 = DIRECTION('',(-1.,4.52345554697E-15)); +#27103 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27104 = PCURVE('',#26760,#27105); +#27105 = DEFINITIONAL_REPRESENTATION('',(#27106),#27110); +#27106 = CIRCLE('',#27107,4.3); +#27107 = AXIS2_PLACEMENT_2D('',#27108,#27109); +#27108 = CARTESIAN_POINT('',(8.329919999964,-16.36372881364)); +#27109 = DIRECTION('',(0.707106781187,-0.707106781187)); +#27110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27111 = ORIENTED_EDGE('',*,*,#27008,.F.); +#27112 = ORIENTED_EDGE('',*,*,#27113,.T.); +#27113 = EDGE_CURVE('',#27009,#27063,#27114,.T.); +#27114 = SURFACE_CURVE('',#27115,(#27120,#27127),.PCURVE_S1.); +#27115 = CIRCLE('',#27116,4.3); +#27116 = AXIS2_PLACEMENT_3D('',#27117,#27118,#27119); +#27117 = CARTESIAN_POINT('',(-10.32992,16.363728813559,42.5)); +#27118 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27119 = DIRECTION('',(-0.707106781187,0.707106781187, + -1.923319432344E-15)); +#27120 = PCURVE('',#27024,#27121); +#27121 = DEFINITIONAL_REPRESENTATION('',(#27122),#27126); +#27122 = LINE('',#27123,#27124); +#27123 = CARTESIAN_POINT('',(6.28318530718,1.)); +#27124 = VECTOR('',#27125,1.); +#27125 = DIRECTION('',(-1.,4.52345554697E-15)); +#27126 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27127 = PCURVE('',#26815,#27128); +#27128 = DEFINITIONAL_REPRESENTATION('',(#27129),#27133); +#27129 = CIRCLE('',#27130,4.3); +#27130 = AXIS2_PLACEMENT_2D('',#27131,#27132); +#27131 = CARTESIAN_POINT('',(10.32992,-16.36372881355)); +#27132 = DIRECTION('',(0.707106781187,-0.707106781187)); +#27133 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27134 = ADVANCED_FACE('',(#27135),#27078,.F.); +#27135 = FACE_BOUND('',#27136,.T.); +#27136 = EDGE_LOOP('',(#27137,#27138,#27161,#27189)); +#27137 = ORIENTED_EDGE('',*,*,#27060,.F.); +#27138 = ORIENTED_EDGE('',*,*,#27139,.F.); +#27139 = EDGE_CURVE('',#27140,#27061,#27142,.T.); +#27140 = VERTEX_POINT('',#27141); +#27141 = CARTESIAN_POINT('',(-14.62992,-16.36372881355,43.5)); +#27142 = SURFACE_CURVE('',#27143,(#27147,#27154),.PCURVE_S1.); +#27143 = LINE('',#27144,#27145); +#27144 = CARTESIAN_POINT('',(-14.62992,-10.33186440682,43.5)); +#27145 = VECTOR('',#27146,1.); +#27146 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#27147 = PCURVE('',#27078,#27148); +#27148 = DEFINITIONAL_REPRESENTATION('',(#27149),#27153); +#27149 = LINE('',#27150,#27151); +#27150 = CARTESIAN_POINT('',(10.331864406739,-1.767462504906E-14)); +#27151 = VECTOR('',#27152,1.); +#27152 = DIRECTION('',(1.,8.006938187993E-29)); +#27153 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27154 = PCURVE('',#26760,#27155); +#27155 = DEFINITIONAL_REPRESENTATION('',(#27156),#27160); +#27156 = LINE('',#27157,#27158); +#27157 = CARTESIAN_POINT('',(12.629919999964,10.331864406738)); +#27158 = VECTOR('',#27159,1.); +#27159 = DIRECTION('',(2.339250078244E-31,-1.)); +#27160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27161 = ORIENTED_EDGE('',*,*,#27162,.F.); +#27162 = EDGE_CURVE('',#27163,#27140,#27165,.T.); +#27163 = VERTEX_POINT('',#27164); +#27164 = CARTESIAN_POINT('',(-14.62992,-16.36372881355,42.5)); +#27165 = SURFACE_CURVE('',#27166,(#27170,#27177),.PCURVE_S1.); +#27166 = LINE('',#27167,#27168); +#27167 = CARTESIAN_POINT('',(-14.62992,-16.36372881355,43.5)); +#27168 = VECTOR('',#27169,1.); +#27169 = DIRECTION('',(7.91599702251E-57,1.710690767248E-15,1.)); +#27170 = PCURVE('',#27078,#27171); +#27171 = DEFINITIONAL_REPRESENTATION('',(#27172),#27176); +#27172 = LINE('',#27173,#27174); +#27173 = CARTESIAN_POINT('',(4.3,-7.355970299166E-15)); +#27174 = VECTOR('',#27175,1.); +#27175 = DIRECTION('',(-1.991873785683E-29,-1.)); +#27176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27177 = PCURVE('',#27178,#27183); +#27178 = CYLINDRICAL_SURFACE('',#27179,4.3); +#27179 = AXIS2_PLACEMENT_3D('',#27180,#27181,#27182); +#27180 = CARTESIAN_POINT('',(-10.32992,-16.36372881355,43.5)); +#27181 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27182 = DIRECTION('',(-0.707106781187,-0.707106781187, + 1.209641042034E-15)); +#27183 = DEFINITIONAL_REPRESENTATION('',(#27184),#27188); +#27184 = LINE('',#27185,#27186); +#27185 = CARTESIAN_POINT('',(0.785398163397,0.)); +#27186 = VECTOR('',#27187,1.); +#27187 = DIRECTION('',(0.,-1.)); +#27188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27189 = ORIENTED_EDGE('',*,*,#27190,.T.); +#27190 = EDGE_CURVE('',#27163,#27063,#27191,.T.); +#27191 = SURFACE_CURVE('',#27192,(#27196,#27203),.PCURVE_S1.); +#27192 = LINE('',#27193,#27194); +#27193 = CARTESIAN_POINT('',(-14.62992,-20.66372881355,42.5)); +#27194 = VECTOR('',#27195,1.); +#27195 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#27196 = PCURVE('',#27078,#27197); +#27197 = DEFINITIONAL_REPRESENTATION('',(#27198),#27202); +#27198 = LINE('',#27199,#27200); +#27199 = CARTESIAN_POINT('',(1.710690767248E-15,1.)); +#27200 = VECTOR('',#27201,1.); +#27201 = DIRECTION('',(1.,0.)); +#27202 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27203 = PCURVE('',#26815,#27204); +#27204 = DEFINITIONAL_REPRESENTATION('',(#27205),#27209); +#27205 = LINE('',#27206,#27207); +#27206 = CARTESIAN_POINT('',(14.62992,20.663728813559)); +#27207 = VECTOR('',#27208,1.); +#27208 = DIRECTION('',(-1.747532916004E-45,-1.)); +#27209 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27210 = ADVANCED_FACE('',(#27211),#27178,.F.); +#27211 = FACE_BOUND('',#27212,.F.); +#27212 = EDGE_LOOP('',(#27213,#27238,#27260,#27261)); +#27213 = ORIENTED_EDGE('',*,*,#27214,.F.); +#27214 = EDGE_CURVE('',#27215,#27217,#27219,.T.); +#27215 = VERTEX_POINT('',#27216); +#27216 = CARTESIAN_POINT('',(-10.32992,-20.66372881355,43.5)); +#27217 = VERTEX_POINT('',#27218); +#27218 = CARTESIAN_POINT('',(-10.32992,-20.66372881355,42.5)); +#27219 = SURFACE_CURVE('',#27220,(#27224,#27231),.PCURVE_S1.); +#27220 = LINE('',#27221,#27222); +#27221 = CARTESIAN_POINT('',(-10.32992,-20.66372881355,43.5)); +#27222 = VECTOR('',#27223,1.); +#27223 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27224 = PCURVE('',#27178,#27225); +#27225 = DEFINITIONAL_REPRESENTATION('',(#27226),#27230); +#27226 = LINE('',#27227,#27228); +#27227 = CARTESIAN_POINT('',(-0.785398163397,7.105427357601E-15)); +#27228 = VECTOR('',#27229,1.); +#27229 = DIRECTION('',(0.,1.)); +#27230 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27231 = PCURVE('',#26788,#27232); +#27232 = DEFINITIONAL_REPRESENTATION('',(#27233),#27237); +#27233 = LINE('',#27234,#27235); +#27234 = CARTESIAN_POINT('',(24.95984,-2.519180823538E-14)); +#27235 = VECTOR('',#27236,1.); +#27236 = DIRECTION('',(1.009293658748E-15,1.)); +#27237 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27238 = ORIENTED_EDGE('',*,*,#27239,.F.); +#27239 = EDGE_CURVE('',#27140,#27215,#27240,.T.); +#27240 = SURFACE_CURVE('',#27241,(#27246,#27253),.PCURVE_S1.); +#27241 = CIRCLE('',#27242,4.3); +#27242 = AXIS2_PLACEMENT_3D('',#27243,#27244,#27245); +#27243 = CARTESIAN_POINT('',(-10.32992,-16.36372881355,43.5)); +#27244 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27245 = DIRECTION('',(-0.707106781187,-0.707106781187, + 3.992707407793E-16)); +#27246 = PCURVE('',#27178,#27247); +#27247 = DEFINITIONAL_REPRESENTATION('',(#27248),#27252); +#27248 = LINE('',#27249,#27250); +#27249 = CARTESIAN_POINT('',(6.28318530718,3.19744231092E-14)); +#27250 = VECTOR('',#27251,1.); +#27251 = DIRECTION('',(-1.,-4.52345554697E-15)); +#27252 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27253 = PCURVE('',#26760,#27254); +#27254 = DEFINITIONAL_REPRESENTATION('',(#27255),#27259); +#27255 = CIRCLE('',#27256,4.3); +#27256 = AXIS2_PLACEMENT_2D('',#27257,#27258); +#27257 = CARTESIAN_POINT('',(8.329919999964,16.363728813477)); +#27258 = DIRECTION('',(0.707106781187,0.707106781187)); +#27259 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27260 = ORIENTED_EDGE('',*,*,#27162,.F.); +#27261 = ORIENTED_EDGE('',*,*,#27262,.T.); +#27262 = EDGE_CURVE('',#27163,#27217,#27263,.T.); +#27263 = SURFACE_CURVE('',#27264,(#27269,#27276),.PCURVE_S1.); +#27264 = CIRCLE('',#27265,4.3); +#27265 = AXIS2_PLACEMENT_3D('',#27266,#27267,#27268); +#27266 = CARTESIAN_POINT('',(-10.32992,-16.36372881355,42.5)); +#27267 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27268 = DIRECTION('',(-0.707106781187,-0.707106781187, + 4.959626517245E-16)); +#27269 = PCURVE('',#27178,#27270); +#27270 = DEFINITIONAL_REPRESENTATION('',(#27271),#27275); +#27271 = LINE('',#27272,#27273); +#27272 = CARTESIAN_POINT('',(6.28318530718,1.)); +#27273 = VECTOR('',#27274,1.); +#27274 = DIRECTION('',(-1.,-4.52345554697E-15)); +#27275 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27276 = PCURVE('',#26815,#27277); +#27277 = DEFINITIONAL_REPRESENTATION('',(#27278),#27282); +#27278 = CIRCLE('',#27279,4.3); +#27279 = AXIS2_PLACEMENT_2D('',#27280,#27281); +#27280 = CARTESIAN_POINT('',(10.32992,16.363728813559)); +#27281 = DIRECTION('',(0.707106781187,0.707106781187)); +#27282 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27283 = ADVANCED_FACE('',(#27284),#26788,.F.); +#27284 = FACE_BOUND('',#27285,.T.); +#27285 = EDGE_LOOP('',(#27286,#27287,#27308,#27309)); +#27286 = ORIENTED_EDGE('',*,*,#26772,.F.); +#27287 = ORIENTED_EDGE('',*,*,#27288,.T.); +#27288 = EDGE_CURVE('',#26773,#27217,#27289,.T.); +#27289 = SURFACE_CURVE('',#27290,(#27294,#27301),.PCURVE_S1.); +#27290 = LINE('',#27291,#27292); +#27291 = CARTESIAN_POINT('',(14.62992,-20.66372881355,42.5)); +#27292 = VECTOR('',#27293,1.); +#27293 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27294 = PCURVE('',#26788,#27295); +#27295 = DEFINITIONAL_REPRESENTATION('',(#27296),#27300); +#27296 = LINE('',#27297,#27298); +#27297 = CARTESIAN_POINT('',(1.009293658748E-15,1.)); +#27298 = VECTOR('',#27299,1.); +#27299 = DIRECTION('',(1.,0.)); +#27300 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27301 = PCURVE('',#26815,#27302); +#27302 = DEFINITIONAL_REPRESENTATION('',(#27303),#27307); +#27303 = LINE('',#27304,#27305); +#27304 = CARTESIAN_POINT('',(-14.62992,20.663728813559)); +#27305 = VECTOR('',#27306,1.); +#27306 = DIRECTION('',(1.,-4.090164401715E-48)); +#27307 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27308 = ORIENTED_EDGE('',*,*,#27214,.F.); +#27309 = ORIENTED_EDGE('',*,*,#27310,.F.); +#27310 = EDGE_CURVE('',#26744,#27215,#27311,.T.); +#27311 = SURFACE_CURVE('',#27312,(#27316,#27323),.PCURVE_S1.); +#27312 = LINE('',#27313,#27314); +#27313 = CARTESIAN_POINT('',(6.314959999982,-20.66372881355,43.5)); +#27314 = VECTOR('',#27315,1.); +#27315 = DIRECTION('',(-1.,-2.339250078243E-31,-1.146036670579E-15)); +#27316 = PCURVE('',#26788,#27317); +#27317 = DEFINITIONAL_REPRESENTATION('',(#27318),#27322); +#27318 = LINE('',#27319,#27320); +#27319 = CARTESIAN_POINT('',(8.314960000018,-8.392236400765E-15)); +#27320 = VECTOR('',#27321,1.); +#27321 = DIRECTION('',(1.,1.367430118306E-16)); +#27322 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27323 = PCURVE('',#26760,#27324); +#27324 = DEFINITIONAL_REPRESENTATION('',(#27325),#27329); +#27325 = LINE('',#27326,#27327); +#27326 = CARTESIAN_POINT('',(-8.314960000018,20.663728813477)); +#27327 = VECTOR('',#27328,1.); +#27328 = DIRECTION('',(1.,2.339250078243E-31)); +#27329 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27330 = ADVANCED_FACE('',(#27331,#27341),#26815,.T.); +#27331 = FACE_BOUND('',#27332,.T.); +#27332 = EDGE_LOOP('',(#27333,#27334,#27335,#27336,#27337,#27338,#27339, + #27340)); +#27333 = ORIENTED_EDGE('',*,*,#26800,.T.); +#27334 = ORIENTED_EDGE('',*,*,#26882,.F.); +#27335 = ORIENTED_EDGE('',*,*,#26959,.T.); +#27336 = ORIENTED_EDGE('',*,*,#27036,.F.); +#27337 = ORIENTED_EDGE('',*,*,#27113,.T.); +#27338 = ORIENTED_EDGE('',*,*,#27190,.F.); +#27339 = ORIENTED_EDGE('',*,*,#27262,.T.); +#27340 = ORIENTED_EDGE('',*,*,#27288,.F.); +#27341 = FACE_BOUND('',#27342,.T.); +#27342 = EDGE_LOOP('',(#27343)); +#27343 = ORIENTED_EDGE('',*,*,#27344,.F.); +#27344 = EDGE_CURVE('',#27345,#27345,#27347,.T.); +#27345 = VERTEX_POINT('',#27346); +#27346 = CARTESIAN_POINT('',(1.05,9.19391431097E-15,42.5)); +#27347 = SURFACE_CURVE('',#27348,(#27353,#27360),.PCURVE_S1.); +#27348 = CIRCLE('',#27349,1.05); +#27349 = AXIS2_PLACEMENT_3D('',#27350,#27351,#27352); +#27350 = CARTESIAN_POINT('',(0.,9.06532639706E-15,42.5)); +#27351 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27352 = DIRECTION('',(-1.,2.172012619703E-44,-1.009293658748E-15)); +#27353 = PCURVE('',#26815,#27354); +#27354 = DEFINITIONAL_REPRESENTATION('',(#27355),#27359); +#27355 = CIRCLE('',#27356,1.05); +#27356 = AXIS2_PLACEMENT_2D('',#27357,#27358); +#27357 = CARTESIAN_POINT('',(5.199138784779E-186,8.08838021796E-15)); +#27358 = DIRECTION('',(1.,-2.172421636144E-44)); +#27359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27360 = PCURVE('',#27361,#27366); +#27361 = CYLINDRICAL_SURFACE('',#27362,1.05); +#27362 = AXIS2_PLACEMENT_3D('',#27363,#27364,#27365); +#27363 = CARTESIAN_POINT('',(0.,1.07760171643E-14,43.5)); +#27364 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27365 = DIRECTION('',(-1.,1.726589343463E-30,-2.953660448682E-45)); +#27366 = DEFINITIONAL_REPRESENTATION('',(#27367),#27371); +#27367 = LINE('',#27368,#27369); +#27368 = CARTESIAN_POINT('',(6.28318530718,1.)); +#27369 = VECTOR('',#27370,1.); +#27370 = DIRECTION('',(-1.,0.)); +#27371 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27372 = ADVANCED_FACE('',(#27373),#27361,.F.); +#27373 = FACE_BOUND('',#27374,.F.); +#27374 = EDGE_LOOP('',(#27375,#27398,#27425,#27426)); +#27375 = ORIENTED_EDGE('',*,*,#27376,.T.); +#27376 = EDGE_CURVE('',#27345,#27377,#27379,.T.); +#27377 = VERTEX_POINT('',#27378); +#27378 = CARTESIAN_POINT('',(1.05,4.91718739285E-15,40.)); +#27379 = SEAM_CURVE('',#27380,(#27384,#27391),.PCURVE_S1.); +#27380 = LINE('',#27381,#27382); +#27381 = CARTESIAN_POINT('',(1.05,1.064742925039E-14,43.5)); +#27382 = VECTOR('',#27383,1.); +#27383 = DIRECTION('',(-7.91599702251E-57,-1.710690767248E-15,-1.)); +#27384 = PCURVE('',#27361,#27385); +#27385 = DEFINITIONAL_REPRESENTATION('',(#27386),#27390); +#27386 = LINE('',#27387,#27388); +#27387 = CARTESIAN_POINT('',(3.14159265359,0.)); +#27388 = VECTOR('',#27389,1.); +#27389 = DIRECTION('',(0.,1.)); +#27390 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27391 = PCURVE('',#27361,#27392); +#27392 = DEFINITIONAL_REPRESENTATION('',(#27393),#27397); +#27393 = LINE('',#27394,#27395); +#27394 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#27395 = VECTOR('',#27396,1.); +#27396 = DIRECTION('',(0.,1.)); +#27397 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27398 = ORIENTED_EDGE('',*,*,#27399,.T.); +#27399 = EDGE_CURVE('',#27377,#27377,#27400,.T.); +#27400 = SURFACE_CURVE('',#27401,(#27406,#27413),.PCURVE_S1.); +#27401 = CIRCLE('',#27402,1.05); +#27402 = AXIS2_PLACEMENT_3D('',#27403,#27404,#27405); +#27403 = CARTESIAN_POINT('',(0.,4.78859947894E-15,40.)); +#27404 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27405 = DIRECTION('',(-1.,-2.339250078244E-31,-1.146036670579E-15)); +#27406 = PCURVE('',#27361,#27407); +#27407 = DEFINITIONAL_REPRESENTATION('',(#27408),#27412); +#27408 = LINE('',#27409,#27410); +#27409 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#27410 = VECTOR('',#27411,1.); +#27411 = DIRECTION('',(-1.,0.)); +#27412 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27413 = PCURVE('',#27414,#27419); +#27414 = PLANE('',#27415); +#27415 = AXIS2_PLACEMENT_3D('',#27416,#27417,#27418); +#27416 = CARTESIAN_POINT('',(-2.000000000036,-8.231945353349E-11,40.)); +#27417 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27418 = DIRECTION('',(-1.,1.45092644297E-114,-1.146036670579E-15)); +#27419 = DEFINITIONAL_REPRESENTATION('',(#27420),#27424); +#27420 = CIRCLE('',#27421,1.05); +#27421 = AXIS2_PLACEMENT_2D('',#27422,#27423); +#27422 = CARTESIAN_POINT('',(-2.000000000036,-8.232424213297E-11)); +#27423 = DIRECTION('',(1.,2.339250078244E-31)); +#27424 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27425 = ORIENTED_EDGE('',*,*,#27376,.F.); +#27426 = ORIENTED_EDGE('',*,*,#27344,.F.); +#27427 = ADVANCED_FACE('',(#27428),#27441,.T.); +#27428 = FACE_BOUND('',#27429,.T.); +#27429 = EDGE_LOOP('',(#27430,#27464,#27487,#27513)); +#27430 = ORIENTED_EDGE('',*,*,#27431,.F.); +#27431 = EDGE_CURVE('',#27432,#27432,#27434,.T.); +#27432 = VERTEX_POINT('',#27433); +#27433 = CARTESIAN_POINT('',(-10.70444504221,-33.23836007982,44.5)); +#27434 = SURFACE_CURVE('',#27435,(#27440,#27452),.PCURVE_S1.); +#27435 = CIRCLE('',#27436,6.5); +#27436 = AXIS2_PLACEMENT_3D('',#27437,#27438,#27439); +#27437 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,44.5)); +#27438 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27439 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27440 = PCURVE('',#27441,#27446); +#27441 = CYLINDRICAL_SURFACE('',#27442,6.5); +#27442 = AXIS2_PLACEMENT_3D('',#27443,#27444,#27445); +#27443 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,43.5)); +#27444 = DIRECTION('',(7.91599702251E-57,-1.266038408908E-99,1.)); +#27445 = DIRECTION('',(-1.,-1.051140062189E-155,7.91599702251E-57)); +#27446 = DEFINITIONAL_REPRESENTATION('',(#27447),#27451); +#27447 = LINE('',#27448,#27449); +#27448 = CARTESIAN_POINT('',(-6.28318530718,1.)); +#27449 = VECTOR('',#27450,1.); +#27450 = DIRECTION('',(1.,0.)); +#27451 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27452 = PCURVE('',#27453,#27458); +#27453 = PLANE('',#27454); +#27454 = AXIS2_PLACEMENT_3D('',#27455,#27456,#27457); +#27455 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,44.5)); +#27456 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27457 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27458 = DEFINITIONAL_REPRESENTATION('',(#27459),#27463); +#27459 = CIRCLE('',#27460,6.5); +#27460 = AXIS2_PLACEMENT_2D('',#27461,#27462); +#27461 = CARTESIAN_POINT('',(0.,0.)); +#27462 = DIRECTION('',(1.,-4.090164401715E-48)); +#27463 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27464 = ORIENTED_EDGE('',*,*,#27465,.T.); +#27465 = EDGE_CURVE('',#27432,#27466,#27468,.T.); +#27466 = VERTEX_POINT('',#27467); +#27467 = CARTESIAN_POINT('',(-10.70444504221,-33.23836007982,43.5)); +#27468 = SEAM_CURVE('',#27469,(#27473,#27480),.PCURVE_S1.); +#27469 = LINE('',#27470,#27471); +#27470 = CARTESIAN_POINT('',(-10.70444504221,-33.23836007982,43.5)); +#27471 = VECTOR('',#27472,1.); +#27472 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#27473 = PCURVE('',#27441,#27474); +#27474 = DEFINITIONAL_REPRESENTATION('',(#27475),#27479); +#27475 = LINE('',#27476,#27477); +#27476 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#27477 = VECTOR('',#27478,1.); +#27478 = DIRECTION('',(0.,-1.)); +#27479 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27480 = PCURVE('',#27441,#27481); +#27481 = DEFINITIONAL_REPRESENTATION('',(#27482),#27486); +#27482 = LINE('',#27483,#27484); +#27483 = CARTESIAN_POINT('',(3.14159265359,0.)); +#27484 = VECTOR('',#27485,1.); +#27485 = DIRECTION('',(0.,-1.)); +#27486 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27487 = ORIENTED_EDGE('',*,*,#27488,.F.); +#27488 = EDGE_CURVE('',#27466,#27466,#27489,.T.); +#27489 = SURFACE_CURVE('',#27490,(#27495,#27502),.PCURVE_S1.); +#27490 = CIRCLE('',#27491,6.5); +#27491 = AXIS2_PLACEMENT_3D('',#27492,#27493,#27494); +#27492 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,43.5)); +#27493 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#27494 = DIRECTION('',(-1.,-1.960514351287E-30,-1.146036670579E-15)); +#27495 = PCURVE('',#27441,#27496); +#27496 = DEFINITIONAL_REPRESENTATION('',(#27497),#27501); +#27497 = LINE('',#27498,#27499); +#27498 = CARTESIAN_POINT('',(6.28318530718,7.105427357601E-15)); +#27499 = VECTOR('',#27500,1.); +#27500 = DIRECTION('',(-1.,0.)); +#27501 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27502 = PCURVE('',#26760,#27503); +#27503 = DEFINITIONAL_REPRESENTATION('',(#27504),#27512); +#27504 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27505,#27506,#27507,#27508 + ,#27509,#27510,#27511),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27505 = CARTESIAN_POINT('',(21.704445042183,33.238360079744)); +#27506 = CARTESIAN_POINT('',(21.704445042183,21.980029830546)); +#27507 = CARTESIAN_POINT('',(11.954445042183,27.609194955145)); +#27508 = CARTESIAN_POINT('',(2.204445042183,33.238360079744)); +#27509 = CARTESIAN_POINT('',(11.954445042183,38.867525204343)); +#27510 = CARTESIAN_POINT('',(21.704445042183,44.496690328942)); +#27511 = CARTESIAN_POINT('',(21.704445042183,33.238360079744)); +#27512 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27513 = ORIENTED_EDGE('',*,*,#27465,.F.); +#27514 = ADVANCED_FACE('',(#27515,#27518),#27453,.T.); +#27515 = FACE_BOUND('',#27516,.T.); +#27516 = EDGE_LOOP('',(#27517)); +#27517 = ORIENTED_EDGE('',*,*,#27431,.T.); +#27518 = FACE_BOUND('',#27519,.T.); +#27519 = EDGE_LOOP('',(#27520)); +#27520 = ORIENTED_EDGE('',*,*,#27521,.T.); +#27521 = EDGE_CURVE('',#27522,#27522,#27524,.T.); +#27522 = VERTEX_POINT('',#27523); +#27523 = CARTESIAN_POINT('',(-12.20444504221,-33.23836007982,44.5)); +#27524 = SURFACE_CURVE('',#27525,(#27530,#27541),.PCURVE_S1.); +#27525 = CIRCLE('',#27526,5.); +#27526 = AXIS2_PLACEMENT_3D('',#27527,#27528,#27529); +#27527 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,44.5)); +#27528 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#27529 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27530 = PCURVE('',#27453,#27531); +#27531 = DEFINITIONAL_REPRESENTATION('',(#27532),#27540); +#27532 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27533,#27534,#27535,#27536 + ,#27537,#27538,#27539),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27533 = CARTESIAN_POINT('',(5.,-2.045082200858E-47)); +#27534 = CARTESIAN_POINT('',(5.,-8.660254037844)); +#27535 = CARTESIAN_POINT('',(-2.5,-4.330127018922)); +#27536 = CARTESIAN_POINT('',(-10.,-1.224646799147E-15)); +#27537 = CARTESIAN_POINT('',(-2.5,4.330127018922)); +#27538 = CARTESIAN_POINT('',(5.,8.660254037844)); +#27539 = CARTESIAN_POINT('',(5.,-2.045082200858E-47)); +#27540 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27541 = PCURVE('',#27542,#27547); +#27542 = CYLINDRICAL_SURFACE('',#27543,5.); +#27543 = AXIS2_PLACEMENT_3D('',#27544,#27545,#27546); +#27544 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,43.5)); +#27545 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#27546 = DIRECTION('',(-1.,-1.051140062189E-155,7.91599702251E-57)); +#27547 = DEFINITIONAL_REPRESENTATION('',(#27548),#27552); +#27548 = LINE('',#27549,#27550); +#27549 = CARTESIAN_POINT('',(0.,-1.)); +#27550 = VECTOR('',#27551,1.); +#27551 = DIRECTION('',(1.,0.)); +#27552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27553 = ADVANCED_FACE('',(#27554),#27568,.F.); +#27554 = FACE_BOUND('',#27555,.F.); +#27555 = EDGE_LOOP('',(#27556,#27586,#27617,#27618)); +#27556 = ORIENTED_EDGE('',*,*,#27557,.T.); +#27557 = EDGE_CURVE('',#27558,#27560,#27562,.T.); +#27558 = VERTEX_POINT('',#27559); +#27559 = CARTESIAN_POINT('',(22.311112605611,-41.73651813908,43.5)); +#27560 = VERTEX_POINT('',#27561); +#27561 = CARTESIAN_POINT('',(22.311112605611,-41.73651813908,42.5)); +#27562 = SEAM_CURVE('',#27563,(#27567,#27579),.PCURVE_S1.); +#27563 = LINE('',#27564,#27565); +#27564 = CARTESIAN_POINT('',(22.311112605611,-41.73651813908,43.5)); +#27565 = VECTOR('',#27566,1.); +#27566 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#27567 = PCURVE('',#27568,#27573); +#27568 = CYLINDRICAL_SURFACE('',#27569,7.8); +#27569 = AXIS2_PLACEMENT_3D('',#27570,#27571,#27572); +#27570 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,43.5)); +#27571 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#27572 = DIRECTION('',(-1.,-1.051140062189E-155,7.91599702251E-57)); +#27573 = DEFINITIONAL_REPRESENTATION('',(#27574),#27578); +#27574 = LINE('',#27575,#27576); +#27575 = CARTESIAN_POINT('',(9.424777960769,0.)); +#27576 = VECTOR('',#27577,1.); +#27577 = DIRECTION('',(0.,1.)); +#27578 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27579 = PCURVE('',#27568,#27580); +#27580 = DEFINITIONAL_REPRESENTATION('',(#27581),#27585); +#27581 = LINE('',#27582,#27583); +#27582 = CARTESIAN_POINT('',(3.14159265359,0.)); +#27583 = VECTOR('',#27584,1.); +#27584 = DIRECTION('',(0.,1.)); +#27585 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27586 = ORIENTED_EDGE('',*,*,#27587,.F.); +#27587 = EDGE_CURVE('',#27560,#27560,#27588,.T.); +#27588 = SURFACE_CURVE('',#27589,(#27594,#27601),.PCURVE_S1.); +#27589 = CIRCLE('',#27590,7.8); +#27590 = AXIS2_PLACEMENT_3D('',#27591,#27592,#27593); +#27591 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,42.5)); +#27592 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#27593 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27594 = PCURVE('',#27568,#27595); +#27595 = DEFINITIONAL_REPRESENTATION('',(#27596),#27600); +#27596 = LINE('',#27597,#27598); +#27597 = CARTESIAN_POINT('',(0.,1.)); +#27598 = VECTOR('',#27599,1.); +#27599 = DIRECTION('',(1.,0.)); +#27600 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27601 = PCURVE('',#27602,#27607); +#27602 = PLANE('',#27603); +#27603 = AXIS2_PLACEMENT_3D('',#27604,#27605,#27606); +#27604 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,42.5)); +#27605 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27606 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27607 = DEFINITIONAL_REPRESENTATION('',(#27608),#27616); +#27608 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27609,#27610,#27611,#27612 + ,#27613,#27614,#27615),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27609 = CARTESIAN_POINT('',(7.8,-3.190328233338E-47)); +#27610 = CARTESIAN_POINT('',(7.8,-13.50999629903)); +#27611 = CARTESIAN_POINT('',(-3.9,-6.754998149519)); +#27612 = CARTESIAN_POINT('',(-15.6,-1.91044900667E-15)); +#27613 = CARTESIAN_POINT('',(-3.9,6.754998149519)); +#27614 = CARTESIAN_POINT('',(7.8,13.509996299037)); +#27615 = CARTESIAN_POINT('',(7.8,-3.190328233338E-47)); +#27616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27617 = ORIENTED_EDGE('',*,*,#27557,.F.); +#27618 = ORIENTED_EDGE('',*,*,#27619,.T.); +#27619 = EDGE_CURVE('',#27558,#27558,#27620,.T.); +#27620 = SURFACE_CURVE('',#27621,(#27626,#27633),.PCURVE_S1.); +#27621 = CIRCLE('',#27622,7.8); +#27622 = AXIS2_PLACEMENT_3D('',#27623,#27624,#27625); +#27623 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,43.5)); +#27624 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#27625 = DIRECTION('',(-1.,-1.960514351287E-30,-1.146036670579E-15)); +#27626 = PCURVE('',#27568,#27627); +#27627 = DEFINITIONAL_REPRESENTATION('',(#27628),#27632); +#27628 = LINE('',#27629,#27630); +#27629 = CARTESIAN_POINT('',(0.,9.237055564881E-14)); +#27630 = VECTOR('',#27631,1.); +#27631 = DIRECTION('',(1.,0.)); +#27632 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27633 = PCURVE('',#26760,#27634); +#27634 = DEFINITIONAL_REPRESENTATION('',(#27635),#27643); +#27635 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27636,#27637,#27638,#27639 + ,#27640,#27641,#27642),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27636 = CARTESIAN_POINT('',(-8.711112605647,41.736518139007)); +#27637 = CARTESIAN_POINT('',(-8.711112605647,28.226521839969)); +#27638 = CARTESIAN_POINT('',(-20.41111260564,34.981519989488)); +#27639 = CARTESIAN_POINT('',(-32.11111260564,41.736518139007)); +#27640 = CARTESIAN_POINT('',(-20.41111260564,48.491516288525)); +#27641 = CARTESIAN_POINT('',(-8.711112605647,55.246514438044)); +#27642 = CARTESIAN_POINT('',(-8.711112605647,41.736518139007)); +#27643 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27644 = ADVANCED_FACE('',(#27645,#27648),#27602,.T.); +#27645 = FACE_BOUND('',#27646,.T.); +#27646 = EDGE_LOOP('',(#27647)); +#27647 = ORIENTED_EDGE('',*,*,#27587,.F.); +#27648 = FACE_BOUND('',#27649,.T.); +#27649 = EDGE_LOOP('',(#27650)); +#27650 = ORIENTED_EDGE('',*,*,#27651,.F.); +#27651 = EDGE_CURVE('',#27652,#27652,#27654,.T.); +#27652 = VERTEX_POINT('',#27653); +#27653 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,42.5)); +#27654 = SURFACE_CURVE('',#27655,(#27660,#27667),.PCURVE_S1.); +#27655 = CIRCLE('',#27656,1.05); +#27656 = AXIS2_PLACEMENT_3D('',#27657,#27658,#27659); +#27657 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,42.5)); +#27658 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27659 = DIRECTION('',(-1.,6.018076613179E-31,-1.009293658748E-15)); +#27660 = PCURVE('',#27602,#27661); +#27661 = DEFINITIONAL_REPRESENTATION('',(#27662),#27666); +#27662 = CIRCLE('',#27663,1.05); +#27663 = AXIS2_PLACEMENT_2D('',#27664,#27665); +#27664 = CARTESIAN_POINT('',(0.,0.)); +#27665 = DIRECTION('',(1.,-6.018076613179E-31)); +#27666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27667 = PCURVE('',#27668,#27673); +#27668 = CYLINDRICAL_SURFACE('',#27669,1.05); +#27669 = AXIS2_PLACEMENT_3D('',#27670,#27671,#27672); +#27670 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,43.5)); +#27671 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#27672 = DIRECTION('',(-1.,2.328397004781E-30,-5.371511615942E-45)); +#27673 = DEFINITIONAL_REPRESENTATION('',(#27674),#27678); +#27674 = LINE('',#27675,#27676); +#27675 = CARTESIAN_POINT('',(6.28318530718,1.)); +#27676 = VECTOR('',#27677,1.); +#27677 = DIRECTION('',(-1.,0.)); +#27678 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27679 = ADVANCED_FACE('',(#27680),#27542,.F.); +#27680 = FACE_BOUND('',#27681,.F.); +#27681 = EDGE_LOOP('',(#27682,#27705,#27736,#27737)); +#27682 = ORIENTED_EDGE('',*,*,#27683,.T.); +#27683 = EDGE_CURVE('',#27522,#27684,#27686,.T.); +#27684 = VERTEX_POINT('',#27685); +#27685 = CARTESIAN_POINT('',(-12.20444504221,-33.23836007982,42.5)); +#27686 = SEAM_CURVE('',#27687,(#27691,#27698),.PCURVE_S1.); +#27687 = LINE('',#27688,#27689); +#27688 = CARTESIAN_POINT('',(-12.20444504221,-33.23836007982,43.5)); +#27689 = VECTOR('',#27690,1.); +#27690 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#27691 = PCURVE('',#27542,#27692); +#27692 = DEFINITIONAL_REPRESENTATION('',(#27693),#27697); +#27693 = LINE('',#27694,#27695); +#27694 = CARTESIAN_POINT('',(9.424777960769,0.)); +#27695 = VECTOR('',#27696,1.); +#27696 = DIRECTION('',(0.,1.)); +#27697 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27698 = PCURVE('',#27542,#27699); +#27699 = DEFINITIONAL_REPRESENTATION('',(#27700),#27704); +#27700 = LINE('',#27701,#27702); +#27701 = CARTESIAN_POINT('',(3.14159265359,0.)); +#27702 = VECTOR('',#27703,1.); +#27703 = DIRECTION('',(0.,1.)); +#27704 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27705 = ORIENTED_EDGE('',*,*,#27706,.F.); +#27706 = EDGE_CURVE('',#27684,#27684,#27707,.T.); +#27707 = SURFACE_CURVE('',#27708,(#27713,#27720),.PCURVE_S1.); +#27708 = CIRCLE('',#27709,5.); +#27709 = AXIS2_PLACEMENT_3D('',#27710,#27711,#27712); +#27710 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,42.5)); +#27711 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#27712 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27713 = PCURVE('',#27542,#27714); +#27714 = DEFINITIONAL_REPRESENTATION('',(#27715),#27719); +#27715 = LINE('',#27716,#27717); +#27716 = CARTESIAN_POINT('',(0.,1.)); +#27717 = VECTOR('',#27718,1.); +#27718 = DIRECTION('',(1.,0.)); +#27719 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27720 = PCURVE('',#27721,#27726); +#27721 = PLANE('',#27722); +#27722 = AXIS2_PLACEMENT_3D('',#27723,#27724,#27725); +#27723 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,42.5)); +#27724 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27725 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#27726 = DEFINITIONAL_REPRESENTATION('',(#27727),#27735); +#27727 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27728,#27729,#27730,#27731 + ,#27732,#27733,#27734),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27728 = CARTESIAN_POINT('',(5.,-2.045082200858E-47)); +#27729 = CARTESIAN_POINT('',(5.,-8.660254037844)); +#27730 = CARTESIAN_POINT('',(-2.5,-4.330127018922)); +#27731 = CARTESIAN_POINT('',(-10.,-1.224646799147E-15)); +#27732 = CARTESIAN_POINT('',(-2.5,4.330127018922)); +#27733 = CARTESIAN_POINT('',(5.,8.660254037844)); +#27734 = CARTESIAN_POINT('',(5.,-2.045082200858E-47)); +#27735 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27736 = ORIENTED_EDGE('',*,*,#27683,.F.); +#27737 = ORIENTED_EDGE('',*,*,#27521,.T.); +#27738 = ADVANCED_FACE('',(#27739,#27742),#27721,.T.); +#27739 = FACE_BOUND('',#27740,.T.); +#27740 = EDGE_LOOP('',(#27741)); +#27741 = ORIENTED_EDGE('',*,*,#27706,.F.); +#27742 = FACE_BOUND('',#27743,.T.); +#27743 = EDGE_LOOP('',(#27744)); +#27744 = ORIENTED_EDGE('',*,*,#27745,.F.); +#27745 = EDGE_CURVE('',#27746,#27746,#27748,.T.); +#27746 = VERTEX_POINT('',#27747); +#27747 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,42.5)); +#27748 = SURFACE_CURVE('',#27749,(#27754,#27761),.PCURVE_S1.); +#27749 = CIRCLE('',#27750,1.05); +#27750 = AXIS2_PLACEMENT_3D('',#27751,#27752,#27753); +#27751 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,42.5)); +#27752 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#27753 = DIRECTION('',(-1.,8.034154872571E-32,-1.009293658748E-15)); +#27754 = PCURVE('',#27721,#27755); +#27755 = DEFINITIONAL_REPRESENTATION('',(#27756),#27760); +#27756 = CIRCLE('',#27757,1.05); +#27757 = AXIS2_PLACEMENT_2D('',#27758,#27759); +#27758 = CARTESIAN_POINT('',(0.,0.)); +#27759 = DIRECTION('',(1.,-8.034154872571E-32)); +#27760 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27761 = PCURVE('',#27762,#27767); +#27762 = CYLINDRICAL_SURFACE('',#27763,1.05); +#27763 = AXIS2_PLACEMENT_3D('',#27764,#27765,#27766); +#27764 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,43.5)); +#27765 = DIRECTION('',(1.153478467143E-15,-1.153478467143E-15,-1.)); +#27766 = DIRECTION('',(-1.,-1.663140717723E-31,-1.153478467143E-15)); +#27767 = DEFINITIONAL_REPRESENTATION('',(#27768),#27772); +#27768 = LINE('',#27769,#27770); +#27769 = CARTESIAN_POINT('',(6.28318530718,1.)); +#27770 = VECTOR('',#27771,1.); +#27771 = DIRECTION('',(-1.,0.)); +#27772 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27773 = ADVANCED_FACE('',(#27774),#27668,.F.); +#27774 = FACE_BOUND('',#27775,.F.); +#27775 = EDGE_LOOP('',(#27776,#27799,#27821,#27822)); +#27776 = ORIENTED_EDGE('',*,*,#27777,.T.); +#27777 = EDGE_CURVE('',#27652,#27778,#27780,.T.); +#27778 = VERTEX_POINT('',#27779); +#27779 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,40.)); +#27780 = SEAM_CURVE('',#27781,(#27785,#27792),.PCURVE_S1.); +#27781 = LINE('',#27782,#27783); +#27782 = CARTESIAN_POINT('',(15.561112605611,-41.73651813908,43.5)); +#27783 = VECTOR('',#27784,1.); +#27784 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#27785 = PCURVE('',#27668,#27786); +#27786 = DEFINITIONAL_REPRESENTATION('',(#27787),#27791); +#27787 = LINE('',#27788,#27789); +#27788 = CARTESIAN_POINT('',(3.14159265359,0.)); +#27789 = VECTOR('',#27790,1.); +#27790 = DIRECTION('',(0.,1.)); +#27791 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27792 = PCURVE('',#27668,#27793); +#27793 = DEFINITIONAL_REPRESENTATION('',(#27794),#27798); +#27794 = LINE('',#27795,#27796); +#27795 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#27796 = VECTOR('',#27797,1.); +#27797 = DIRECTION('',(0.,1.)); +#27798 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27799 = ORIENTED_EDGE('',*,*,#27800,.T.); +#27800 = EDGE_CURVE('',#27778,#27778,#27801,.T.); +#27801 = SURFACE_CURVE('',#27802,(#27807,#27814),.PCURVE_S1.); +#27802 = CIRCLE('',#27803,1.05); +#27803 = AXIS2_PLACEMENT_3D('',#27804,#27805,#27806); +#27804 = CARTESIAN_POINT('',(14.511112605611,-41.73651813908,40.)); +#27805 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27806 = DIRECTION('',(-1.,3.678826534935E-31,-1.146036670579E-15)); +#27807 = PCURVE('',#27668,#27808); +#27808 = DEFINITIONAL_REPRESENTATION('',(#27809),#27813); +#27809 = LINE('',#27810,#27811); +#27810 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#27811 = VECTOR('',#27812,1.); +#27812 = DIRECTION('',(-1.,0.)); +#27813 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27814 = PCURVE('',#27414,#27815); +#27815 = DEFINITIONAL_REPRESENTATION('',(#27816),#27820); +#27816 = CIRCLE('',#27817,1.05); +#27817 = AXIS2_PLACEMENT_2D('',#27818,#27819); +#27818 = CARTESIAN_POINT('',(-16.51111260564,41.736518139007)); +#27819 = DIRECTION('',(1.,-3.678826534935E-31)); +#27820 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27821 = ORIENTED_EDGE('',*,*,#27777,.F.); +#27822 = ORIENTED_EDGE('',*,*,#27651,.F.); +#27823 = ADVANCED_FACE('',(#27824),#27762,.F.); +#27824 = FACE_BOUND('',#27825,.F.); +#27825 = EDGE_LOOP('',(#27826,#27849,#27871,#27872)); +#27826 = ORIENTED_EDGE('',*,*,#27827,.T.); +#27827 = EDGE_CURVE('',#27746,#27828,#27830,.T.); +#27828 = VERTEX_POINT('',#27829); +#27829 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,40.)); +#27830 = SEAM_CURVE('',#27831,(#27835,#27842),.PCURVE_S1.); +#27831 = LINE('',#27832,#27833); +#27832 = CARTESIAN_POINT('',(-16.15444504221,-33.23836007982,43.5)); +#27833 = VECTOR('',#27834,1.); +#27834 = DIRECTION('',(1.153478467143E-15,-1.153478467143E-15,-1.)); +#27835 = PCURVE('',#27762,#27836); +#27836 = DEFINITIONAL_REPRESENTATION('',(#27837),#27841); +#27837 = LINE('',#27838,#27839); +#27838 = CARTESIAN_POINT('',(3.14159265359,7.105427357601E-15)); +#27839 = VECTOR('',#27840,1.); +#27840 = DIRECTION('',(2.6645352591E-15,1.)); +#27841 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27842 = PCURVE('',#27762,#27843); +#27843 = DEFINITIONAL_REPRESENTATION('',(#27844),#27848); +#27844 = LINE('',#27845,#27846); +#27845 = CARTESIAN_POINT('',(-3.14159265359,7.105427357601E-15)); +#27846 = VECTOR('',#27847,1.); +#27847 = DIRECTION('',(2.6645352591E-15,1.)); +#27848 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27849 = ORIENTED_EDGE('',*,*,#27850,.T.); +#27850 = EDGE_CURVE('',#27828,#27828,#27851,.T.); +#27851 = SURFACE_CURVE('',#27852,(#27857,#27864),.PCURVE_S1.); +#27852 = CIRCLE('',#27853,1.05); +#27853 = AXIS2_PLACEMENT_3D('',#27854,#27855,#27856); +#27854 = CARTESIAN_POINT('',(-17.20444504221,-33.23836007982,40.)); +#27855 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27856 = DIRECTION('',(-1.,-1.535834590986E-31,-1.146036670579E-15)); +#27857 = PCURVE('',#27762,#27858); +#27858 = DEFINITIONAL_REPRESENTATION('',(#27859),#27863); +#27859 = LINE('',#27860,#27861); +#27860 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#27861 = VECTOR('',#27862,1.); +#27862 = DIRECTION('',(-1.,0.)); +#27863 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27864 = PCURVE('',#27414,#27865); +#27865 = DEFINITIONAL_REPRESENTATION('',(#27866),#27870); +#27866 = CIRCLE('',#27867,1.05); +#27867 = AXIS2_PLACEMENT_2D('',#27868,#27869); +#27868 = CARTESIAN_POINT('',(15.204445042183,33.238360079744)); +#27869 = DIRECTION('',(1.,1.535834590986E-31)); +#27870 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27871 = ORIENTED_EDGE('',*,*,#27827,.F.); +#27872 = ORIENTED_EDGE('',*,*,#27745,.F.); +#27873 = ADVANCED_FACE('',(#27874),#27888,.F.); +#27874 = FACE_BOUND('',#27875,.F.); +#27875 = EDGE_LOOP('',(#27876,#27906,#27928,#27929)); +#27876 = ORIENTED_EDGE('',*,*,#27877,.T.); +#27877 = EDGE_CURVE('',#27878,#27880,#27882,.T.); +#27878 = VERTEX_POINT('',#27879); +#27879 = CARTESIAN_POINT('',(-11.25,47.850000000023,43.5)); +#27880 = VERTEX_POINT('',#27881); +#27881 = CARTESIAN_POINT('',(-11.25,47.850000000023,40.)); +#27882 = SEAM_CURVE('',#27883,(#27887,#27899),.PCURVE_S1.); +#27883 = LINE('',#27884,#27885); +#27884 = CARTESIAN_POINT('',(-11.25,47.850000000023,43.5)); +#27885 = VECTOR('',#27886,1.); +#27886 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#27887 = PCURVE('',#27888,#27893); +#27888 = CYLINDRICAL_SURFACE('',#27889,1.05); +#27889 = AXIS2_PLACEMENT_3D('',#27890,#27891,#27892); +#27890 = CARTESIAN_POINT('',(-12.3,47.850000000023,43.5)); +#27891 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#27892 = DIRECTION('',(-1.,-3.326281435446E-31,-1.153478467143E-15)); +#27893 = DEFINITIONAL_REPRESENTATION('',(#27894),#27898); +#27894 = LINE('',#27895,#27896); +#27895 = CARTESIAN_POINT('',(9.424777960769,7.105427357601E-15)); +#27896 = VECTOR('',#27897,1.); +#27897 = DIRECTION('',(0.,1.)); +#27898 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27899 = PCURVE('',#27888,#27900); +#27900 = DEFINITIONAL_REPRESENTATION('',(#27901),#27905); +#27901 = LINE('',#27902,#27903); +#27902 = CARTESIAN_POINT('',(3.14159265359,7.105427357601E-15)); +#27903 = VECTOR('',#27904,1.); +#27904 = DIRECTION('',(0.,1.)); +#27905 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27906 = ORIENTED_EDGE('',*,*,#27907,.T.); +#27907 = EDGE_CURVE('',#27880,#27880,#27908,.T.); +#27908 = SURFACE_CURVE('',#27909,(#27914,#27921),.PCURVE_S1.); +#27909 = CIRCLE('',#27910,1.05); +#27910 = AXIS2_PLACEMENT_3D('',#27911,#27912,#27913); +#27911 = CARTESIAN_POINT('',(-12.3,47.850000000023,40.)); +#27912 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#27913 = DIRECTION('',(-1.,-3.198975308709E-31,-1.146036670579E-15)); +#27914 = PCURVE('',#27888,#27915); +#27915 = DEFINITIONAL_REPRESENTATION('',(#27916),#27920); +#27916 = LINE('',#27917,#27918); +#27917 = CARTESIAN_POINT('',(12.566370614359,3.5)); +#27918 = VECTOR('',#27919,1.); +#27919 = DIRECTION('',(-1.,0.)); +#27920 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27921 = PCURVE('',#27414,#27922); +#27922 = DEFINITIONAL_REPRESENTATION('',(#27923),#27927); +#27923 = CIRCLE('',#27924,1.05); +#27924 = AXIS2_PLACEMENT_2D('',#27925,#27926); +#27925 = CARTESIAN_POINT('',(10.299999999967,-47.8500000001)); +#27926 = DIRECTION('',(1.,3.198975308709E-31)); +#27927 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27928 = ORIENTED_EDGE('',*,*,#27877,.F.); +#27929 = ORIENTED_EDGE('',*,*,#27930,.T.); +#27930 = EDGE_CURVE('',#27878,#27878,#27931,.T.); +#27931 = SURFACE_CURVE('',#27932,(#27937,#27944),.PCURVE_S1.); +#27932 = CIRCLE('',#27933,1.05); +#27933 = AXIS2_PLACEMENT_3D('',#27934,#27935,#27936); +#27934 = CARTESIAN_POINT('',(-12.3,47.850000000023,43.5)); +#27935 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#27936 = DIRECTION('',(-1.,-3.198975308709E-31,-1.146036670579E-15)); +#27937 = PCURVE('',#27888,#27938); +#27938 = DEFINITIONAL_REPRESENTATION('',(#27939),#27943); +#27939 = LINE('',#27940,#27941); +#27940 = CARTESIAN_POINT('',(0.,7.105427357601E-15)); +#27941 = VECTOR('',#27942,1.); +#27942 = DIRECTION('',(1.,0.)); +#27943 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27944 = PCURVE('',#26760,#27945); +#27945 = DEFINITIONAL_REPRESENTATION('',(#27946),#27954); +#27946 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#27947,#27948,#27949,#27950 + ,#27951,#27952,#27953),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#27947 = CARTESIAN_POINT('',(11.349999999967,-47.8500000001)); +#27948 = CARTESIAN_POINT('',(11.349999999967,-49.66865334805)); +#27949 = CARTESIAN_POINT('',(9.774999999967,-48.75932667407)); +#27950 = CARTESIAN_POINT('',(8.199999999967,-47.8500000001)); +#27951 = CARTESIAN_POINT('',(9.774999999967,-46.94067332613)); +#27952 = CARTESIAN_POINT('',(11.349999999967,-46.03134665215)); +#27953 = CARTESIAN_POINT('',(11.349999999967,-47.8500000001)); +#27954 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27955 = ADVANCED_FACE('',(#27956),#27970,.F.); +#27956 = FACE_BOUND('',#27957,.T.); +#27957 = EDGE_LOOP('',(#27958,#27988,#28016,#28039)); +#27958 = ORIENTED_EDGE('',*,*,#27959,.F.); +#27959 = EDGE_CURVE('',#27960,#27962,#27964,.T.); +#27960 = VERTEX_POINT('',#27961); +#27961 = CARTESIAN_POINT('',(16.000000000012,38.099999999996,40.)); +#27962 = VERTEX_POINT('',#27963); +#27963 = CARTESIAN_POINT('',(16.000000000012,57.599999999996,40.)); +#27964 = SURFACE_CURVE('',#27965,(#27969,#27981),.PCURVE_S1.); +#27965 = LINE('',#27966,#27967); +#27966 = CARTESIAN_POINT('',(16.000000000012,28.799999999957,40.)); +#27967 = VECTOR('',#27968,1.); +#27968 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#27969 = PCURVE('',#27970,#27975); +#27970 = PLANE('',#27971); +#27971 = AXIS2_PLACEMENT_3D('',#27972,#27973,#27974); +#27972 = CARTESIAN_POINT('',(16.000000000012,57.599999999996,43.5)); +#27973 = DIRECTION('',(1.,2.46655620498E-31,1.153478467143E-15)); +#27974 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#27975 = DEFINITIONAL_REPRESENTATION('',(#27976),#27980); +#27976 = LINE('',#27977,#27978); +#27977 = CARTESIAN_POINT('',(28.800000000039,3.5)); +#27978 = VECTOR('',#27979,1.); +#27979 = DIRECTION('',(-1.,8.006938187993E-29)); +#27980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27981 = PCURVE('',#27414,#27982); +#27982 = DEFINITIONAL_REPRESENTATION('',(#27983),#27987); +#27983 = LINE('',#27984,#27985); +#27984 = CARTESIAN_POINT('',(-18.00000000004,-28.80000000003)); +#27985 = VECTOR('',#27986,1.); +#27986 = DIRECTION('',(2.339250078243E-31,-1.)); +#27987 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#27988 = ORIENTED_EDGE('',*,*,#27989,.F.); +#27989 = EDGE_CURVE('',#27990,#27960,#27992,.T.); +#27990 = VERTEX_POINT('',#27991); +#27991 = CARTESIAN_POINT('',(16.000000000012,38.099999999996,43.5)); +#27992 = SURFACE_CURVE('',#27993,(#27997,#28004),.PCURVE_S1.); +#27993 = LINE('',#27994,#27995); +#27994 = CARTESIAN_POINT('',(16.000000000012,38.099999999996,43.5)); +#27995 = VECTOR('',#27996,1.); +#27996 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#27997 = PCURVE('',#27970,#27998); +#27998 = DEFINITIONAL_REPRESENTATION('',(#27999),#28003); +#27999 = LINE('',#28000,#28001); +#28000 = CARTESIAN_POINT('',(19.5,3.335846996133E-14)); +#28001 = VECTOR('',#28002,1.); +#28002 = DIRECTION('',(5.962661670382E-16,1.)); +#28003 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28004 = PCURVE('',#28005,#28010); +#28005 = PLANE('',#28006); +#28006 = AXIS2_PLACEMENT_3D('',#28007,#28008,#28009); +#28007 = CARTESIAN_POINT('',(16.000000000012,38.099999999996,43.5)); +#28008 = DIRECTION('',(-2.328397004781E-30,-1.,2.306956934286E-15)); +#28009 = DIRECTION('',(-1.,-1.646773859418E-45,-1.009293658748E-15)); +#28010 = DEFINITIONAL_REPRESENTATION('',(#28011),#28015); +#28011 = LINE('',#28012,#28013); +#28012 = CARTESIAN_POINT('',(-0.,0.)); +#28013 = VECTOR('',#28014,1.); +#28014 = DIRECTION('',(-1.441848083946E-16,1.)); +#28015 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28016 = ORIENTED_EDGE('',*,*,#28017,.F.); +#28017 = EDGE_CURVE('',#28018,#27990,#28020,.T.); +#28018 = VERTEX_POINT('',#28019); +#28019 = CARTESIAN_POINT('',(16.000000000012,57.599999999996,43.5)); +#28020 = SURFACE_CURVE('',#28021,(#28025,#28032),.PCURVE_S1.); +#28021 = LINE('',#28022,#28023); +#28022 = CARTESIAN_POINT('',(16.000000000012,28.799999999957,43.5)); +#28023 = VECTOR('',#28024,1.); +#28024 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#28025 = PCURVE('',#27970,#28026); +#28026 = DEFINITIONAL_REPRESENTATION('',(#28027),#28031); +#28027 = LINE('',#28028,#28029); +#28028 = CARTESIAN_POINT('',(28.800000000039,-5.020808890961E-14)); +#28029 = VECTOR('',#28030,1.); +#28030 = DIRECTION('',(1.,-8.006938187993E-29)); +#28031 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28032 = PCURVE('',#26760,#28033); +#28033 = DEFINITIONAL_REPRESENTATION('',(#28034),#28038); +#28034 = LINE('',#28035,#28036); +#28035 = CARTESIAN_POINT('',(-18.00000000004,-28.80000000003)); +#28036 = VECTOR('',#28037,1.); +#28037 = DIRECTION('',(-2.339250078243E-31,1.)); +#28038 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28039 = ORIENTED_EDGE('',*,*,#28040,.T.); +#28040 = EDGE_CURVE('',#28018,#27962,#28041,.T.); +#28041 = SURFACE_CURVE('',#28042,(#28046,#28053),.PCURVE_S1.); +#28042 = LINE('',#28043,#28044); +#28043 = CARTESIAN_POINT('',(16.000000000012,57.599999999996,43.5)); +#28044 = VECTOR('',#28045,1.); +#28045 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28046 = PCURVE('',#27970,#28047); +#28047 = DEFINITIONAL_REPRESENTATION('',(#28048),#28052); +#28048 = LINE('',#28049,#28050); +#28049 = CARTESIAN_POINT('',(0.,0.)); +#28050 = VECTOR('',#28051,1.); +#28051 = DIRECTION('',(5.962661670382E-16,1.)); +#28052 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28053 = PCURVE('',#28054,#28059); +#28054 = PLANE('',#28055); +#28055 = AXIS2_PLACEMENT_3D('',#28056,#28057,#28058); +#28056 = CARTESIAN_POINT('',(-9.999999999988,57.599999999996,43.5)); +#28057 = DIRECTION('',(2.328397004781E-30,1.,-2.306956934286E-15)); +#28058 = DIRECTION('',(1.,1.646773859418E-45,1.009293658748E-15)); +#28059 = DEFINITIONAL_REPRESENTATION('',(#28060),#28064); +#28060 = LINE('',#28061,#28062); +#28061 = CARTESIAN_POINT('',(26.,2.624163512746E-14)); +#28062 = VECTOR('',#28063,1.); +#28063 = DIRECTION('',(1.441848083946E-16,1.)); +#28064 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28065 = ADVANCED_FACE('',(#28066),#28054,.F.); +#28066 = FACE_BOUND('',#28067,.T.); +#28067 = EDGE_LOOP('',(#28068,#28091,#28092,#28115)); +#28068 = ORIENTED_EDGE('',*,*,#28069,.F.); +#28069 = EDGE_CURVE('',#27962,#28070,#28072,.T.); +#28070 = VERTEX_POINT('',#28071); +#28071 = CARTESIAN_POINT('',(-9.999999999988,57.599999999996,40.)); +#28072 = SURFACE_CURVE('',#28073,(#28077,#28084),.PCURVE_S1.); +#28073 = LINE('',#28074,#28075); +#28074 = CARTESIAN_POINT('',(-6.000000000012,57.599999999996,40.)); +#28075 = VECTOR('',#28076,1.); +#28076 = DIRECTION('',(-1.,-3.154602393578E-31,-1.146036670579E-15)); +#28077 = PCURVE('',#28054,#28078); +#28078 = DEFINITIONAL_REPRESENTATION('',(#28079),#28083); +#28079 = LINE('',#28080,#28081); +#28080 = CARTESIAN_POINT('',(3.999999999976,3.5)); +#28081 = VECTOR('',#28082,1.); +#28082 = DIRECTION('',(-1.,1.367430118306E-16)); +#28083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28084 = PCURVE('',#27414,#28085); +#28085 = DEFINITIONAL_REPRESENTATION('',(#28086),#28090); +#28086 = LINE('',#28087,#28088); +#28087 = CARTESIAN_POINT('',(3.999999999976,-57.60000000007)); +#28088 = VECTOR('',#28089,1.); +#28089 = DIRECTION('',(1.,3.154602393578E-31)); +#28090 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28091 = ORIENTED_EDGE('',*,*,#28040,.F.); +#28092 = ORIENTED_EDGE('',*,*,#28093,.F.); +#28093 = EDGE_CURVE('',#28094,#28018,#28096,.T.); +#28094 = VERTEX_POINT('',#28095); +#28095 = CARTESIAN_POINT('',(-9.999999999988,57.599999999996,43.5)); +#28096 = SURFACE_CURVE('',#28097,(#28101,#28108),.PCURVE_S1.); +#28097 = LINE('',#28098,#28099); +#28098 = CARTESIAN_POINT('',(-6.000000000012,57.599999999996,43.5)); +#28099 = VECTOR('',#28100,1.); +#28100 = DIRECTION('',(1.,3.154602393578E-31,1.146036670579E-15)); +#28101 = PCURVE('',#28054,#28102); +#28102 = DEFINITIONAL_REPRESENTATION('',(#28103),#28107); +#28103 = LINE('',#28104,#28105); +#28104 = CARTESIAN_POINT('',(3.999999999976,4.037174634969E-15)); +#28105 = VECTOR('',#28106,1.); +#28106 = DIRECTION('',(1.,-1.367430118306E-16)); +#28107 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28108 = PCURVE('',#26760,#28109); +#28109 = DEFINITIONAL_REPRESENTATION('',(#28110),#28114); +#28110 = LINE('',#28111,#28112); +#28111 = CARTESIAN_POINT('',(3.999999999976,-57.60000000007)); +#28112 = VECTOR('',#28113,1.); +#28113 = DIRECTION('',(-1.,-3.154602393578E-31)); +#28114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28115 = ORIENTED_EDGE('',*,*,#28116,.T.); +#28116 = EDGE_CURVE('',#28094,#28070,#28117,.T.); +#28117 = SURFACE_CURVE('',#28118,(#28122,#28129),.PCURVE_S1.); +#28118 = LINE('',#28119,#28120); +#28119 = CARTESIAN_POINT('',(-9.999999999988,57.599999999996,43.5)); +#28120 = VECTOR('',#28121,1.); +#28121 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28122 = PCURVE('',#28054,#28123); +#28123 = DEFINITIONAL_REPRESENTATION('',(#28124),#28128); +#28124 = LINE('',#28125,#28126); +#28125 = CARTESIAN_POINT('',(0.,0.)); +#28126 = VECTOR('',#28127,1.); +#28127 = DIRECTION('',(1.441848083946E-16,1.)); +#28128 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28129 = PCURVE('',#28130,#28135); +#28130 = PLANE('',#28131); +#28131 = AXIS2_PLACEMENT_3D('',#28132,#28133,#28134); +#28132 = CARTESIAN_POINT('',(-9.999999999988,38.099999999996,43.5)); +#28133 = DIRECTION('',(-1.,-2.46655620498E-31,-1.153478467143E-15)); +#28134 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#28135 = DEFINITIONAL_REPRESENTATION('',(#28136),#28140); +#28136 = LINE('',#28137,#28138); +#28137 = CARTESIAN_POINT('',(19.5,-3.335846996133E-14)); +#28138 = VECTOR('',#28139,1.); +#28139 = DIRECTION('',(-5.962661670382E-16,1.)); +#28140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28141 = ADVANCED_FACE('',(#28142),#28130,.F.); +#28142 = FACE_BOUND('',#28143,.T.); +#28143 = EDGE_LOOP('',(#28144,#28167,#28168,#28191)); +#28144 = ORIENTED_EDGE('',*,*,#28145,.F.); +#28145 = EDGE_CURVE('',#28070,#28146,#28148,.T.); +#28146 = VERTEX_POINT('',#28147); +#28147 = CARTESIAN_POINT('',(-9.999999999988,38.099999999996,40.)); +#28148 = SURFACE_CURVE('',#28149,(#28153,#28160),.PCURVE_S1.); +#28149 = LINE('',#28150,#28151); +#28150 = CARTESIAN_POINT('',(-9.999999999988,19.049999999957,40.)); +#28151 = VECTOR('',#28152,1.); +#28152 = DIRECTION('',(-1.726589343463E-30,-1.,1.710690767248E-15)); +#28153 = PCURVE('',#28130,#28154); +#28154 = DEFINITIONAL_REPRESENTATION('',(#28155),#28159); +#28155 = LINE('',#28156,#28157); +#28156 = CARTESIAN_POINT('',(-19.05000000003,3.5)); +#28157 = VECTOR('',#28158,1.); +#28158 = DIRECTION('',(-1.,-8.006938187993E-29)); +#28159 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28160 = PCURVE('',#27414,#28161); +#28161 = DEFINITIONAL_REPRESENTATION('',(#28162),#28166); +#28162 = LINE('',#28163,#28164); +#28163 = CARTESIAN_POINT('',(7.999999999952,-19.05000000003)); +#28164 = VECTOR('',#28165,1.); +#28165 = DIRECTION('',(-2.339250078243E-31,1.)); +#28166 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28167 = ORIENTED_EDGE('',*,*,#28116,.F.); +#28168 = ORIENTED_EDGE('',*,*,#28169,.F.); +#28169 = EDGE_CURVE('',#28170,#28094,#28172,.T.); +#28170 = VERTEX_POINT('',#28171); +#28171 = CARTESIAN_POINT('',(-9.999999999988,38.099999999996,43.5)); +#28172 = SURFACE_CURVE('',#28173,(#28177,#28184),.PCURVE_S1.); +#28173 = LINE('',#28174,#28175); +#28174 = CARTESIAN_POINT('',(-9.999999999988,19.049999999957,43.5)); +#28175 = VECTOR('',#28176,1.); +#28176 = DIRECTION('',(1.726589343463E-30,1.,-1.710690767248E-15)); +#28177 = PCURVE('',#28130,#28178); +#28178 = DEFINITIONAL_REPRESENTATION('',(#28179),#28183); +#28179 = LINE('',#28180,#28181); +#28180 = CARTESIAN_POINT('',(-19.05000000003,3.258865911614E-14)); +#28181 = VECTOR('',#28182,1.); +#28182 = DIRECTION('',(1.,8.006938187993E-29)); +#28183 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28184 = PCURVE('',#26760,#28185); +#28185 = DEFINITIONAL_REPRESENTATION('',(#28186),#28190); +#28186 = LINE('',#28187,#28188); +#28187 = CARTESIAN_POINT('',(7.999999999952,-19.05000000003)); +#28188 = VECTOR('',#28189,1.); +#28189 = DIRECTION('',(2.339250078243E-31,-1.)); +#28190 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28191 = ORIENTED_EDGE('',*,*,#28192,.T.); +#28192 = EDGE_CURVE('',#28170,#28146,#28193,.T.); +#28193 = SURFACE_CURVE('',#28194,(#28198,#28205),.PCURVE_S1.); +#28194 = LINE('',#28195,#28196); +#28195 = CARTESIAN_POINT('',(-9.999999999988,38.099999999996,43.5)); +#28196 = VECTOR('',#28197,1.); +#28197 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28198 = PCURVE('',#28130,#28199); +#28199 = DEFINITIONAL_REPRESENTATION('',(#28200),#28204); +#28200 = LINE('',#28201,#28202); +#28201 = CARTESIAN_POINT('',(0.,0.)); +#28202 = VECTOR('',#28203,1.); +#28203 = DIRECTION('',(-5.962661670382E-16,1.)); +#28204 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28205 = PCURVE('',#28005,#28206); +#28206 = DEFINITIONAL_REPRESENTATION('',(#28207),#28211); +#28207 = LINE('',#28208,#28209); +#28208 = CARTESIAN_POINT('',(26.,-2.624163512746E-14)); +#28209 = VECTOR('',#28210,1.); +#28210 = DIRECTION('',(-1.441848083946E-16,1.)); +#28211 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28212 = ADVANCED_FACE('',(#28213),#28005,.F.); +#28213 = FACE_BOUND('',#28214,.T.); +#28214 = EDGE_LOOP('',(#28215,#28236,#28237,#28258)); +#28215 = ORIENTED_EDGE('',*,*,#28216,.F.); +#28216 = EDGE_CURVE('',#28146,#27960,#28217,.T.); +#28217 = SURFACE_CURVE('',#28218,(#28222,#28229),.PCURVE_S1.); +#28218 = LINE('',#28219,#28220); +#28219 = CARTESIAN_POINT('',(6.999999999988,38.099999999996,40.)); +#28220 = VECTOR('',#28221,1.); +#28221 = DIRECTION('',(1.,3.154602393578E-31,1.146036670579E-15)); +#28222 = PCURVE('',#28005,#28223); +#28223 = DEFINITIONAL_REPRESENTATION('',(#28224),#28228); +#28224 = LINE('',#28225,#28226); +#28225 = CARTESIAN_POINT('',(9.000000000024,3.5)); +#28226 = VECTOR('',#28227,1.); +#28227 = DIRECTION('',(-1.,-1.367430118306E-16)); +#28228 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28229 = PCURVE('',#27414,#28230); +#28230 = DEFINITIONAL_REPRESENTATION('',(#28231),#28235); +#28231 = LINE('',#28232,#28233); +#28232 = CARTESIAN_POINT('',(-9.000000000024,-38.10000000007)); +#28233 = VECTOR('',#28234,1.); +#28234 = DIRECTION('',(-1.,-3.154602393578E-31)); +#28235 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28236 = ORIENTED_EDGE('',*,*,#28192,.F.); +#28237 = ORIENTED_EDGE('',*,*,#28238,.F.); +#28238 = EDGE_CURVE('',#27990,#28170,#28239,.T.); +#28239 = SURFACE_CURVE('',#28240,(#28244,#28251),.PCURVE_S1.); +#28240 = LINE('',#28241,#28242); +#28241 = CARTESIAN_POINT('',(6.999999999988,38.099999999996,43.5)); +#28242 = VECTOR('',#28243,1.); +#28243 = DIRECTION('',(-1.,-3.154602393578E-31,-1.146036670579E-15)); +#28244 = PCURVE('',#28005,#28245); +#28245 = DEFINITIONAL_REPRESENTATION('',(#28246),#28250); +#28246 = LINE('',#28247,#28248); +#28247 = CARTESIAN_POINT('',(9.000000000024,-9.08364292876E-15)); +#28248 = VECTOR('',#28249,1.); +#28249 = DIRECTION('',(1.,1.367430118306E-16)); +#28250 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28251 = PCURVE('',#26760,#28252); +#28252 = DEFINITIONAL_REPRESENTATION('',(#28253),#28257); +#28253 = LINE('',#28254,#28255); +#28254 = CARTESIAN_POINT('',(-9.000000000024,-38.10000000007)); +#28255 = VECTOR('',#28256,1.); +#28256 = DIRECTION('',(1.,3.154602393578E-31)); +#28257 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28258 = ORIENTED_EDGE('',*,*,#27989,.T.); +#28259 = ADVANCED_FACE('',(#28260),#28274,.F.); +#28260 = FACE_BOUND('',#28261,.F.); +#28261 = EDGE_LOOP('',(#28262,#28292,#28314,#28315)); +#28262 = ORIENTED_EDGE('',*,*,#28263,.T.); +#28263 = EDGE_CURVE('',#28264,#28266,#28268,.T.); +#28264 = VERTEX_POINT('',#28265); +#28265 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,43.5)); +#28266 = VERTEX_POINT('',#28267); +#28267 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,40.)); +#28268 = SEAM_CURVE('',#28269,(#28273,#28285),.PCURVE_S1.); +#28269 = LINE('',#28270,#28271); +#28270 = CARTESIAN_POINT('',(19.350000000028,47.849999999969,43.5)); +#28271 = VECTOR('',#28272,1.); +#28272 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28273 = PCURVE('',#28274,#28279); +#28274 = CYLINDRICAL_SURFACE('',#28275,1.05); +#28275 = AXIS2_PLACEMENT_3D('',#28276,#28277,#28278); +#28276 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,43.5)); +#28277 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28278 = DIRECTION('',(-1.,2.328397004781E-30,-5.371511615942E-45)); +#28279 = DEFINITIONAL_REPRESENTATION('',(#28280),#28284); +#28280 = LINE('',#28281,#28282); +#28281 = CARTESIAN_POINT('',(9.424777960769,0.)); +#28282 = VECTOR('',#28283,1.); +#28283 = DIRECTION('',(0.,1.)); +#28284 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28285 = PCURVE('',#28274,#28286); +#28286 = DEFINITIONAL_REPRESENTATION('',(#28287),#28291); +#28287 = LINE('',#28288,#28289); +#28288 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28289 = VECTOR('',#28290,1.); +#28290 = DIRECTION('',(0.,1.)); +#28291 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28292 = ORIENTED_EDGE('',*,*,#28293,.T.); +#28293 = EDGE_CURVE('',#28266,#28266,#28294,.T.); +#28294 = SURFACE_CURVE('',#28295,(#28300,#28307),.PCURVE_S1.); +#28295 = CIRCLE('',#28296,1.05); +#28296 = AXIS2_PLACEMENT_3D('',#28297,#28298,#28299); +#28297 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,40.)); +#28298 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#28299 = DIRECTION('',(-1.,3.678826534935E-31,-1.146036670579E-15)); +#28300 = PCURVE('',#28274,#28301); +#28301 = DEFINITIONAL_REPRESENTATION('',(#28302),#28306); +#28302 = LINE('',#28303,#28304); +#28303 = CARTESIAN_POINT('',(12.566370614359,3.5)); +#28304 = VECTOR('',#28305,1.); +#28305 = DIRECTION('',(-1.,0.)); +#28306 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28307 = PCURVE('',#27414,#28308); +#28308 = DEFINITIONAL_REPRESENTATION('',(#28309),#28313); +#28309 = CIRCLE('',#28310,1.05); +#28310 = AXIS2_PLACEMENT_2D('',#28311,#28312); +#28311 = CARTESIAN_POINT('',(-20.30000000006,-47.85000000005)); +#28312 = DIRECTION('',(1.,-3.678826534935E-31)); +#28313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28314 = ORIENTED_EDGE('',*,*,#28263,.F.); +#28315 = ORIENTED_EDGE('',*,*,#28316,.T.); +#28316 = EDGE_CURVE('',#28264,#28264,#28317,.T.); +#28317 = SURFACE_CURVE('',#28318,(#28323,#28330),.PCURVE_S1.); +#28318 = CIRCLE('',#28319,1.05); +#28319 = AXIS2_PLACEMENT_3D('',#28320,#28321,#28322); +#28320 = CARTESIAN_POINT('',(18.300000000028,47.849999999969,43.5)); +#28321 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#28322 = DIRECTION('',(-1.,3.678826534935E-31,-1.146036670579E-15)); +#28323 = PCURVE('',#28274,#28324); +#28324 = DEFINITIONAL_REPRESENTATION('',(#28325),#28329); +#28325 = LINE('',#28326,#28327); +#28326 = CARTESIAN_POINT('',(0.,0.)); +#28327 = VECTOR('',#28328,1.); +#28328 = DIRECTION('',(1.,0.)); +#28329 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28330 = PCURVE('',#26760,#28331); +#28331 = DEFINITIONAL_REPRESENTATION('',(#28332),#28340); +#28332 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28333,#28334,#28335,#28336 + ,#28337,#28338,#28339),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28333 = CARTESIAN_POINT('',(-19.25000000006,-47.85000000005)); +#28334 = CARTESIAN_POINT('',(-19.25000000006,-49.66865334799)); +#28335 = CARTESIAN_POINT('',(-20.82500000006,-48.75932667402)); +#28336 = CARTESIAN_POINT('',(-22.40000000006,-47.85000000005)); +#28337 = CARTESIAN_POINT('',(-20.82500000006,-46.94067332607)); +#28338 = CARTESIAN_POINT('',(-19.25000000006,-46.0313466521)); +#28339 = CARTESIAN_POINT('',(-19.25000000006,-47.85000000005)); +#28340 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28341 = ADVANCED_FACE('',(#28342),#28356,.F.); +#28342 = FACE_BOUND('',#28343,.F.); +#28343 = EDGE_LOOP('',(#28344,#28374,#28405,#28406)); +#28344 = ORIENTED_EDGE('',*,*,#28345,.T.); +#28345 = EDGE_CURVE('',#28346,#28348,#28350,.T.); +#28346 = VERTEX_POINT('',#28347); +#28347 = CARTESIAN_POINT('',(27.99999999993,-61.60000000011,43.5)); +#28348 = VERTEX_POINT('',#28349); +#28349 = CARTESIAN_POINT('',(27.99999999993,-61.60000000011,41.5)); +#28350 = SEAM_CURVE('',#28351,(#28355,#28367),.PCURVE_S1.); +#28351 = LINE('',#28352,#28353); +#28352 = CARTESIAN_POINT('',(27.99999999993,-61.60000000011,43.5)); +#28353 = VECTOR('',#28354,1.); +#28354 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#28355 = PCURVE('',#28356,#28361); +#28356 = CYLINDRICAL_SURFACE('',#28357,2.); +#28357 = AXIS2_PLACEMENT_3D('',#28358,#28359,#28360); +#28358 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,43.5)); +#28359 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#28360 = DIRECTION('',(-1.,-1.051140062189E-155,7.91599702251E-57)); +#28361 = DEFINITIONAL_REPRESENTATION('',(#28362),#28366); +#28362 = LINE('',#28363,#28364); +#28363 = CARTESIAN_POINT('',(9.424777960769,0.)); +#28364 = VECTOR('',#28365,1.); +#28365 = DIRECTION('',(0.,1.)); +#28366 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28367 = PCURVE('',#28356,#28368); +#28368 = DEFINITIONAL_REPRESENTATION('',(#28369),#28373); +#28369 = LINE('',#28370,#28371); +#28370 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28371 = VECTOR('',#28372,1.); +#28372 = DIRECTION('',(0.,1.)); +#28373 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28374 = ORIENTED_EDGE('',*,*,#28375,.F.); +#28375 = EDGE_CURVE('',#28348,#28348,#28376,.T.); +#28376 = SURFACE_CURVE('',#28377,(#28382,#28389),.PCURVE_S1.); +#28377 = CIRCLE('',#28378,2.); +#28378 = AXIS2_PLACEMENT_3D('',#28379,#28380,#28381); +#28379 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,41.5)); +#28380 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#28381 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28382 = PCURVE('',#28356,#28383); +#28383 = DEFINITIONAL_REPRESENTATION('',(#28384),#28388); +#28384 = LINE('',#28385,#28386); +#28385 = CARTESIAN_POINT('',(0.,2.)); +#28386 = VECTOR('',#28387,1.); +#28387 = DIRECTION('',(1.,0.)); +#28388 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28389 = PCURVE('',#28390,#28395); +#28390 = PLANE('',#28391); +#28391 = AXIS2_PLACEMENT_3D('',#28392,#28393,#28394); +#28392 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,41.5)); +#28393 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28394 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28395 = DEFINITIONAL_REPRESENTATION('',(#28396),#28404); +#28396 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28397,#28398,#28399,#28400 + ,#28401,#28402,#28403),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28397 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28398 = CARTESIAN_POINT('',(2.,-3.464101615138)); +#28399 = CARTESIAN_POINT('',(-1.,-1.732050807569)); +#28400 = CARTESIAN_POINT('',(-4.,-4.898587196589E-16)); +#28401 = CARTESIAN_POINT('',(-1.,1.732050807569)); +#28402 = CARTESIAN_POINT('',(2.,3.464101615138)); +#28403 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28404 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28405 = ORIENTED_EDGE('',*,*,#28345,.F.); +#28406 = ORIENTED_EDGE('',*,*,#28407,.T.); +#28407 = EDGE_CURVE('',#28346,#28346,#28408,.T.); +#28408 = SURFACE_CURVE('',#28409,(#28414,#28421),.PCURVE_S1.); +#28409 = CIRCLE('',#28410,2.); +#28410 = AXIS2_PLACEMENT_3D('',#28411,#28412,#28413); +#28411 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,43.5)); +#28412 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#28413 = DIRECTION('',(-1.,-1.960514351287E-30,-1.146036670579E-15)); +#28414 = PCURVE('',#28356,#28415); +#28415 = DEFINITIONAL_REPRESENTATION('',(#28416),#28420); +#28416 = LINE('',#28417,#28418); +#28417 = CARTESIAN_POINT('',(0.,9.947598300641E-14)); +#28418 = VECTOR('',#28419,1.); +#28419 = DIRECTION('',(1.,0.)); +#28420 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28421 = PCURVE('',#26760,#28422); +#28422 = DEFINITIONAL_REPRESENTATION('',(#28423),#28431); +#28423 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28424,#28425,#28426,#28427 + ,#28428,#28429,#28430),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28424 = CARTESIAN_POINT('',(-25.99999999996,61.600000000031)); +#28425 = CARTESIAN_POINT('',(-25.99999999996,58.135898384893)); +#28426 = CARTESIAN_POINT('',(-28.99999999996,59.867949192462)); +#28427 = CARTESIAN_POINT('',(-31.99999999996,61.600000000031)); +#28428 = CARTESIAN_POINT('',(-28.99999999996,63.3320508076)); +#28429 = CARTESIAN_POINT('',(-25.99999999996,65.064101615169)); +#28430 = CARTESIAN_POINT('',(-25.99999999996,61.600000000031)); +#28431 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28432 = ADVANCED_FACE('',(#28433,#28436),#28390,.T.); +#28433 = FACE_BOUND('',#28434,.T.); +#28434 = EDGE_LOOP('',(#28435)); +#28435 = ORIENTED_EDGE('',*,*,#28375,.F.); +#28436 = FACE_BOUND('',#28437,.T.); +#28437 = EDGE_LOOP('',(#28438)); +#28438 = ORIENTED_EDGE('',*,*,#28439,.F.); +#28439 = EDGE_CURVE('',#28440,#28440,#28442,.T.); +#28440 = VERTEX_POINT('',#28441); +#28441 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011,41.5)); +#28442 = SURFACE_CURVE('',#28443,(#28448,#28455),.PCURVE_S1.); +#28443 = CIRCLE('',#28444,1.05); +#28444 = AXIS2_PLACEMENT_3D('',#28445,#28446,#28447); +#28445 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,41.5)); +#28446 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28447 = DIRECTION('',(-1.,6.018076613179E-31,-1.009293658748E-15)); +#28448 = PCURVE('',#28390,#28449); +#28449 = DEFINITIONAL_REPRESENTATION('',(#28450),#28454); +#28450 = CIRCLE('',#28451,1.05); +#28451 = AXIS2_PLACEMENT_2D('',#28452,#28453); +#28452 = CARTESIAN_POINT('',(0.,0.)); +#28453 = DIRECTION('',(1.,-6.018076613179E-31)); +#28454 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28455 = PCURVE('',#28456,#28461); +#28456 = CYLINDRICAL_SURFACE('',#28457,1.05); +#28457 = AXIS2_PLACEMENT_3D('',#28458,#28459,#28460); +#28458 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,43.5)); +#28459 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28460 = DIRECTION('',(-1.,2.328397004781E-30,-5.371511615942E-45)); +#28461 = DEFINITIONAL_REPRESENTATION('',(#28462),#28466); +#28462 = LINE('',#28463,#28464); +#28463 = CARTESIAN_POINT('',(6.28318530718,2.)); +#28464 = VECTOR('',#28465,1.); +#28465 = DIRECTION('',(-1.,0.)); +#28466 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28467 = ADVANCED_FACE('',(#28468),#28482,.F.); +#28468 = FACE_BOUND('',#28469,.F.); +#28469 = EDGE_LOOP('',(#28470,#28500,#28531,#28532)); +#28470 = ORIENTED_EDGE('',*,*,#28471,.T.); +#28471 = EDGE_CURVE('',#28472,#28474,#28476,.T.); +#28472 = VERTEX_POINT('',#28473); +#28473 = CARTESIAN_POINT('',(28.000000000019,61.6,43.5)); +#28474 = VERTEX_POINT('',#28475); +#28475 = CARTESIAN_POINT('',(28.000000000019,61.6,41.5)); +#28476 = SEAM_CURVE('',#28477,(#28481,#28493),.PCURVE_S1.); +#28477 = LINE('',#28478,#28479); +#28478 = CARTESIAN_POINT('',(28.000000000019,61.6,43.5)); +#28479 = VECTOR('',#28480,1.); +#28480 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#28481 = PCURVE('',#28482,#28487); +#28482 = CYLINDRICAL_SURFACE('',#28483,2.); +#28483 = AXIS2_PLACEMENT_3D('',#28484,#28485,#28486); +#28484 = CARTESIAN_POINT('',(26.000000000019,61.6,43.5)); +#28485 = DIRECTION('',(-7.91599702251E-57,1.266038408908E-99,-1.)); +#28486 = DIRECTION('',(-1.,-1.051140062189E-155,7.91599702251E-57)); +#28487 = DEFINITIONAL_REPRESENTATION('',(#28488),#28492); +#28488 = LINE('',#28489,#28490); +#28489 = CARTESIAN_POINT('',(9.424777960769,0.)); +#28490 = VECTOR('',#28491,1.); +#28491 = DIRECTION('',(0.,1.)); +#28492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28493 = PCURVE('',#28482,#28494); +#28494 = DEFINITIONAL_REPRESENTATION('',(#28495),#28499); +#28495 = LINE('',#28496,#28497); +#28496 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28497 = VECTOR('',#28498,1.); +#28498 = DIRECTION('',(0.,1.)); +#28499 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28500 = ORIENTED_EDGE('',*,*,#28501,.F.); +#28501 = EDGE_CURVE('',#28474,#28474,#28502,.T.); +#28502 = SURFACE_CURVE('',#28503,(#28508,#28515),.PCURVE_S1.); +#28503 = CIRCLE('',#28504,2.); +#28504 = AXIS2_PLACEMENT_3D('',#28505,#28506,#28507); +#28505 = CARTESIAN_POINT('',(26.000000000019,61.6,41.5)); +#28506 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#28507 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28508 = PCURVE('',#28482,#28509); +#28509 = DEFINITIONAL_REPRESENTATION('',(#28510),#28514); +#28510 = LINE('',#28511,#28512); +#28511 = CARTESIAN_POINT('',(0.,2.)); +#28512 = VECTOR('',#28513,1.); +#28513 = DIRECTION('',(1.,0.)); +#28514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28515 = PCURVE('',#28516,#28521); +#28516 = PLANE('',#28517); +#28517 = AXIS2_PLACEMENT_3D('',#28518,#28519,#28520); +#28518 = CARTESIAN_POINT('',(26.000000000019,61.6,41.5)); +#28519 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28520 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28521 = DEFINITIONAL_REPRESENTATION('',(#28522),#28530); +#28522 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28523,#28524,#28525,#28526 + ,#28527,#28528,#28529),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28523 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28524 = CARTESIAN_POINT('',(2.,-3.464101615138)); +#28525 = CARTESIAN_POINT('',(-1.,-1.732050807569)); +#28526 = CARTESIAN_POINT('',(-4.,-4.898587196589E-16)); +#28527 = CARTESIAN_POINT('',(-1.,1.732050807569)); +#28528 = CARTESIAN_POINT('',(2.,3.464101615138)); +#28529 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28531 = ORIENTED_EDGE('',*,*,#28471,.F.); +#28532 = ORIENTED_EDGE('',*,*,#28533,.T.); +#28533 = EDGE_CURVE('',#28472,#28472,#28534,.T.); +#28534 = SURFACE_CURVE('',#28535,(#28540,#28547),.PCURVE_S1.); +#28535 = CIRCLE('',#28536,2.); +#28536 = AXIS2_PLACEMENT_3D('',#28537,#28538,#28539); +#28537 = CARTESIAN_POINT('',(26.000000000019,61.6,43.5)); +#28538 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#28539 = DIRECTION('',(-1.,-1.960514351287E-30,-1.146036670579E-15)); +#28540 = PCURVE('',#28482,#28541); +#28541 = DEFINITIONAL_REPRESENTATION('',(#28542),#28546); +#28542 = LINE('',#28543,#28544); +#28543 = CARTESIAN_POINT('',(0.,-9.947598300641E-14)); +#28544 = VECTOR('',#28545,1.); +#28545 = DIRECTION('',(1.,0.)); +#28546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28547 = PCURVE('',#26760,#28548); +#28548 = DEFINITIONAL_REPRESENTATION('',(#28549),#28557); +#28549 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28550,#28551,#28552,#28553 + ,#28554,#28555,#28556),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28550 = CARTESIAN_POINT('',(-26.00000000005,-61.60000000008)); +#28551 = CARTESIAN_POINT('',(-26.00000000005,-65.06410161522)); +#28552 = CARTESIAN_POINT('',(-29.00000000005,-63.33205080765)); +#28553 = CARTESIAN_POINT('',(-32.00000000005,-61.60000000008)); +#28554 = CARTESIAN_POINT('',(-29.00000000005,-59.86794919251)); +#28555 = CARTESIAN_POINT('',(-26.00000000005,-58.13589838494)); +#28556 = CARTESIAN_POINT('',(-26.00000000005,-61.60000000008)); +#28557 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28558 = ADVANCED_FACE('',(#28559,#28562),#28516,.T.); +#28559 = FACE_BOUND('',#28560,.T.); +#28560 = EDGE_LOOP('',(#28561)); +#28561 = ORIENTED_EDGE('',*,*,#28501,.F.); +#28562 = FACE_BOUND('',#28563,.T.); +#28563 = EDGE_LOOP('',(#28564)); +#28564 = ORIENTED_EDGE('',*,*,#28565,.F.); +#28565 = EDGE_CURVE('',#28566,#28566,#28568,.T.); +#28566 = VERTEX_POINT('',#28567); +#28567 = CARTESIAN_POINT('',(27.050000000019,61.6,41.5)); +#28568 = SURFACE_CURVE('',#28569,(#28574,#28581),.PCURVE_S1.); +#28569 = CIRCLE('',#28570,1.05); +#28570 = AXIS2_PLACEMENT_3D('',#28571,#28572,#28573); +#28571 = CARTESIAN_POINT('',(26.000000000019,61.6,41.5)); +#28572 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28573 = DIRECTION('',(-1.,6.018076613179E-31,-1.009293658748E-15)); +#28574 = PCURVE('',#28516,#28575); +#28575 = DEFINITIONAL_REPRESENTATION('',(#28576),#28580); +#28576 = CIRCLE('',#28577,1.05); +#28577 = AXIS2_PLACEMENT_2D('',#28578,#28579); +#28578 = CARTESIAN_POINT('',(0.,0.)); +#28579 = DIRECTION('',(1.,-6.018076613179E-31)); +#28580 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28581 = PCURVE('',#28582,#28587); +#28582 = CYLINDRICAL_SURFACE('',#28583,1.05); +#28583 = AXIS2_PLACEMENT_3D('',#28584,#28585,#28586); +#28584 = CARTESIAN_POINT('',(26.000000000019,61.6,43.5)); +#28585 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28586 = DIRECTION('',(-1.,2.328397004781E-30,-5.371511615942E-45)); +#28587 = DEFINITIONAL_REPRESENTATION('',(#28588),#28592); +#28588 = LINE('',#28589,#28590); +#28589 = CARTESIAN_POINT('',(6.28318530718,2.)); +#28590 = VECTOR('',#28591,1.); +#28591 = DIRECTION('',(-1.,0.)); +#28592 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28593 = ADVANCED_FACE('',(#28594),#28608,.F.); +#28594 = FACE_BOUND('',#28595,.F.); +#28595 = EDGE_LOOP('',(#28596,#28626,#28657,#28658)); +#28596 = ORIENTED_EDGE('',*,*,#28597,.T.); +#28597 = EDGE_CURVE('',#28598,#28600,#28602,.T.); +#28598 = VERTEX_POINT('',#28599); +#28599 = CARTESIAN_POINT('',(-28.00000000007,-61.60000000026,43.5)); +#28600 = VERTEX_POINT('',#28601); +#28601 = CARTESIAN_POINT('',(-28.00000000007,-61.60000000026,41.5)); +#28602 = SEAM_CURVE('',#28603,(#28607,#28619),.PCURVE_S1.); +#28603 = LINE('',#28604,#28605); +#28604 = CARTESIAN_POINT('',(-28.00000000007,-61.60000000026,43.5)); +#28605 = VECTOR('',#28606,1.); +#28606 = DIRECTION('',(1.110223024625E-15,1.266038408908E-99,-1.)); +#28607 = PCURVE('',#28608,#28613); +#28608 = CYLINDRICAL_SURFACE('',#28609,2.); +#28609 = AXIS2_PLACEMENT_3D('',#28610,#28611,#28612); +#28610 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,43.5)); +#28611 = DIRECTION('',(1.110223024625E-15,1.266038408908E-99,-1.)); +#28612 = DIRECTION('',(-1.,1.405584991629E-114,-1.110223024625E-15)); +#28613 = DEFINITIONAL_REPRESENTATION('',(#28614),#28618); +#28614 = LINE('',#28615,#28616); +#28615 = CARTESIAN_POINT('',(9.424777960769,0.)); +#28616 = VECTOR('',#28617,1.); +#28617 = DIRECTION('',(0.,1.)); +#28618 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28619 = PCURVE('',#28608,#28620); +#28620 = DEFINITIONAL_REPRESENTATION('',(#28621),#28625); +#28621 = LINE('',#28622,#28623); +#28622 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28623 = VECTOR('',#28624,1.); +#28624 = DIRECTION('',(0.,1.)); +#28625 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28626 = ORIENTED_EDGE('',*,*,#28627,.F.); +#28627 = EDGE_CURVE('',#28600,#28600,#28628,.T.); +#28628 = SURFACE_CURVE('',#28629,(#28634,#28641),.PCURVE_S1.); +#28629 = CIRCLE('',#28630,2.); +#28630 = AXIS2_PLACEMENT_3D('',#28631,#28632,#28633); +#28631 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,41.5)); +#28632 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#28633 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28634 = PCURVE('',#28608,#28635); +#28635 = DEFINITIONAL_REPRESENTATION('',(#28636),#28640); +#28636 = LINE('',#28637,#28638); +#28637 = CARTESIAN_POINT('',(0.,2.)); +#28638 = VECTOR('',#28639,1.); +#28639 = DIRECTION('',(1.,0.)); +#28640 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28641 = PCURVE('',#28642,#28647); +#28642 = PLANE('',#28643); +#28643 = AXIS2_PLACEMENT_3D('',#28644,#28645,#28646); +#28644 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,41.5)); +#28645 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28646 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28647 = DEFINITIONAL_REPRESENTATION('',(#28648),#28656); +#28648 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28649,#28650,#28651,#28652 + ,#28653,#28654,#28655),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28649 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28650 = CARTESIAN_POINT('',(2.,-3.464101615138)); +#28651 = CARTESIAN_POINT('',(-1.,-1.732050807569)); +#28652 = CARTESIAN_POINT('',(-4.,-4.898587196589E-16)); +#28653 = CARTESIAN_POINT('',(-1.,1.732050807569)); +#28654 = CARTESIAN_POINT('',(2.,3.464101615138)); +#28655 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28656 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28657 = ORIENTED_EDGE('',*,*,#28597,.F.); +#28658 = ORIENTED_EDGE('',*,*,#28659,.T.); +#28659 = EDGE_CURVE('',#28598,#28598,#28660,.T.); +#28660 = SURFACE_CURVE('',#28661,(#28666,#28673),.PCURVE_S1.); +#28661 = CIRCLE('',#28662,2.); +#28662 = AXIS2_PLACEMENT_3D('',#28663,#28664,#28665); +#28663 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,43.5)); +#28664 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#28665 = DIRECTION('',(-1.,-6.126607347484E-32,-1.146036670579E-15)); +#28666 = PCURVE('',#28608,#28667); +#28667 = DEFINITIONAL_REPRESENTATION('',(#28668),#28672); +#28668 = LINE('',#28669,#28670); +#28669 = CARTESIAN_POINT('',(0.,9.947598300641E-14)); +#28670 = VECTOR('',#28671,1.); +#28671 = DIRECTION('',(1.,0.)); +#28672 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28673 = PCURVE('',#26760,#28674); +#28674 = DEFINITIONAL_REPRESENTATION('',(#28675),#28683); +#28675 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28676,#28677,#28678,#28679 + ,#28680,#28681,#28682),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28676 = CARTESIAN_POINT('',(30.000000000043,61.600000000178)); +#28677 = CARTESIAN_POINT('',(30.000000000043,58.135898385041)); +#28678 = CARTESIAN_POINT('',(27.000000000043,59.86794919261)); +#28679 = CARTESIAN_POINT('',(24.000000000043,61.600000000178)); +#28680 = CARTESIAN_POINT('',(27.000000000043,63.332050807747)); +#28681 = CARTESIAN_POINT('',(30.000000000043,65.064101615316)); +#28682 = CARTESIAN_POINT('',(30.000000000043,61.600000000178)); +#28683 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28684 = ADVANCED_FACE('',(#28685,#28688),#28642,.T.); +#28685 = FACE_BOUND('',#28686,.T.); +#28686 = EDGE_LOOP('',(#28687)); +#28687 = ORIENTED_EDGE('',*,*,#28627,.F.); +#28688 = FACE_BOUND('',#28689,.T.); +#28689 = EDGE_LOOP('',(#28690)); +#28690 = ORIENTED_EDGE('',*,*,#28691,.F.); +#28691 = EDGE_CURVE('',#28692,#28692,#28694,.T.); +#28692 = VERTEX_POINT('',#28693); +#28693 = CARTESIAN_POINT('',(-28.95000000016,-61.60000000003,41.5)); +#28694 = SURFACE_CURVE('',#28695,(#28700,#28707),.PCURVE_S1.); +#28695 = CIRCLE('',#28696,1.05); +#28696 = AXIS2_PLACEMENT_3D('',#28697,#28698,#28699); +#28697 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003,41.5)); +#28698 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28699 = DIRECTION('',(-1.,-8.597252304657E-32,-1.009293658748E-15)); +#28700 = PCURVE('',#28642,#28701); +#28701 = DEFINITIONAL_REPRESENTATION('',(#28702),#28706); +#28702 = CIRCLE('',#28703,1.05); +#28703 = AXIS2_PLACEMENT_2D('',#28704,#28705); +#28704 = CARTESIAN_POINT('',(8.400036222156E-11,-2.282973809997E-10)); +#28705 = DIRECTION('',(1.,8.597252304657E-32)); +#28706 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28707 = PCURVE('',#28708,#28713); +#28708 = CYLINDRICAL_SURFACE('',#28709,1.05); +#28709 = AXIS2_PLACEMENT_3D('',#28710,#28711,#28712); +#28710 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003,43.5)); +#28711 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28712 = DIRECTION('',(-1.,-3.326281435446E-31,-1.153478467143E-15)); +#28713 = DEFINITIONAL_REPRESENTATION('',(#28714),#28718); +#28714 = LINE('',#28715,#28716); +#28715 = CARTESIAN_POINT('',(6.28318530718,2.)); +#28716 = VECTOR('',#28717,1.); +#28717 = DIRECTION('',(-1.,0.)); +#28718 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28719 = ADVANCED_FACE('',(#28720),#28734,.F.); +#28720 = FACE_BOUND('',#28721,.F.); +#28721 = EDGE_LOOP('',(#28722,#28752,#28783,#28784)); +#28722 = ORIENTED_EDGE('',*,*,#28723,.T.); +#28723 = EDGE_CURVE('',#28724,#28726,#28728,.T.); +#28724 = VERTEX_POINT('',#28725); +#28725 = CARTESIAN_POINT('',(-28.00000000007,61.6,43.5)); +#28726 = VERTEX_POINT('',#28727); +#28727 = CARTESIAN_POINT('',(-28.00000000007,61.6,41.5)); +#28728 = SEAM_CURVE('',#28729,(#28733,#28745),.PCURVE_S1.); +#28729 = LINE('',#28730,#28731); +#28730 = CARTESIAN_POINT('',(-28.00000000007,61.6,43.5)); +#28731 = VECTOR('',#28732,1.); +#28732 = DIRECTION('',(1.110223024625E-15,1.266038408908E-99,-1.)); +#28733 = PCURVE('',#28734,#28739); +#28734 = CYLINDRICAL_SURFACE('',#28735,2.); +#28735 = AXIS2_PLACEMENT_3D('',#28736,#28737,#28738); +#28736 = CARTESIAN_POINT('',(-30.00000000007,61.6,43.5)); +#28737 = DIRECTION('',(1.110223024625E-15,1.266038408908E-99,-1.)); +#28738 = DIRECTION('',(-1.,1.405584991629E-114,-1.110223024625E-15)); +#28739 = DEFINITIONAL_REPRESENTATION('',(#28740),#28744); +#28740 = LINE('',#28741,#28742); +#28741 = CARTESIAN_POINT('',(9.424777960769,0.)); +#28742 = VECTOR('',#28743,1.); +#28743 = DIRECTION('',(0.,1.)); +#28744 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28745 = PCURVE('',#28734,#28746); +#28746 = DEFINITIONAL_REPRESENTATION('',(#28747),#28751); +#28747 = LINE('',#28748,#28749); +#28748 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28749 = VECTOR('',#28750,1.); +#28750 = DIRECTION('',(0.,1.)); +#28751 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28752 = ORIENTED_EDGE('',*,*,#28753,.F.); +#28753 = EDGE_CURVE('',#28726,#28726,#28754,.T.); +#28754 = SURFACE_CURVE('',#28755,(#28760,#28767),.PCURVE_S1.); +#28755 = CIRCLE('',#28756,2.); +#28756 = AXIS2_PLACEMENT_3D('',#28757,#28758,#28759); +#28757 = CARTESIAN_POINT('',(-30.00000000007,61.6,41.5)); +#28758 = DIRECTION('',(1.009293658748E-15,-1.710690767248E-15,-1.)); +#28759 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28760 = PCURVE('',#28734,#28761); +#28761 = DEFINITIONAL_REPRESENTATION('',(#28762),#28766); +#28762 = LINE('',#28763,#28764); +#28763 = CARTESIAN_POINT('',(0.,2.)); +#28764 = VECTOR('',#28765,1.); +#28765 = DIRECTION('',(1.,0.)); +#28766 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28767 = PCURVE('',#28768,#28773); +#28768 = PLANE('',#28769); +#28769 = AXIS2_PLACEMENT_3D('',#28770,#28771,#28772); +#28770 = CARTESIAN_POINT('',(-30.00000000007,61.6,41.5)); +#28771 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28772 = DIRECTION('',(-1.,1.277804537842E-114,-1.009293658748E-15)); +#28773 = DEFINITIONAL_REPRESENTATION('',(#28774),#28782); +#28774 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28775,#28776,#28777,#28778 + ,#28779,#28780,#28781),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28775 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28776 = CARTESIAN_POINT('',(2.,-3.464101615138)); +#28777 = CARTESIAN_POINT('',(-1.,-1.732050807569)); +#28778 = CARTESIAN_POINT('',(-4.,-4.898587196589E-16)); +#28779 = CARTESIAN_POINT('',(-1.,1.732050807569)); +#28780 = CARTESIAN_POINT('',(2.,3.464101615138)); +#28781 = CARTESIAN_POINT('',(2.,-8.180328803431E-48)); +#28782 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28783 = ORIENTED_EDGE('',*,*,#28723,.F.); +#28784 = ORIENTED_EDGE('',*,*,#28785,.T.); +#28785 = EDGE_CURVE('',#28724,#28724,#28786,.T.); +#28786 = SURFACE_CURVE('',#28787,(#28792,#28799),.PCURVE_S1.); +#28787 = CIRCLE('',#28788,2.); +#28788 = AXIS2_PLACEMENT_3D('',#28789,#28790,#28791); +#28789 = CARTESIAN_POINT('',(-30.00000000007,61.6,43.5)); +#28790 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#28791 = DIRECTION('',(-1.,-6.126607347484E-32,-1.146036670579E-15)); +#28792 = PCURVE('',#28734,#28793); +#28793 = DEFINITIONAL_REPRESENTATION('',(#28794),#28798); +#28794 = LINE('',#28795,#28796); +#28795 = CARTESIAN_POINT('',(0.,-2.060573933704E-13)); +#28796 = VECTOR('',#28797,1.); +#28797 = DIRECTION('',(1.,0.)); +#28798 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28799 = PCURVE('',#26760,#28800); +#28800 = DEFINITIONAL_REPRESENTATION('',(#28801),#28809); +#28801 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#28802,#28803,#28804,#28805 + ,#28806,#28807,#28808),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#28802 = CARTESIAN_POINT('',(30.000000000039,-61.60000000008)); +#28803 = CARTESIAN_POINT('',(30.000000000039,-65.06410161522)); +#28804 = CARTESIAN_POINT('',(27.000000000039,-63.33205080765)); +#28805 = CARTESIAN_POINT('',(24.000000000039,-61.60000000008)); +#28806 = CARTESIAN_POINT('',(27.000000000039,-59.86794919251)); +#28807 = CARTESIAN_POINT('',(30.000000000039,-58.13589838494)); +#28808 = CARTESIAN_POINT('',(30.000000000039,-61.60000000008)); +#28809 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28810 = ADVANCED_FACE('',(#28811,#28814),#28768,.T.); +#28811 = FACE_BOUND('',#28812,.T.); +#28812 = EDGE_LOOP('',(#28813)); +#28813 = ORIENTED_EDGE('',*,*,#28753,.F.); +#28814 = FACE_BOUND('',#28815,.T.); +#28815 = EDGE_LOOP('',(#28816)); +#28816 = ORIENTED_EDGE('',*,*,#28817,.F.); +#28817 = EDGE_CURVE('',#28818,#28818,#28820,.T.); +#28818 = VERTEX_POINT('',#28819); +#28819 = CARTESIAN_POINT('',(-28.95000000018,61.600000000096,41.5)); +#28820 = SURFACE_CURVE('',#28821,(#28826,#28833),.PCURVE_S1.); +#28821 = CIRCLE('',#28822,1.05); +#28822 = AXIS2_PLACEMENT_3D('',#28823,#28824,#28825); +#28823 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,41.5)); +#28824 = DIRECTION('',(-1.009293658748E-15,1.710690767248E-15,1.)); +#28825 = DIRECTION('',(-1.,-8.597252304657E-32,-1.009293658748E-15)); +#28826 = PCURVE('',#28768,#28827); +#28827 = DEFINITIONAL_REPRESENTATION('',(#28828),#28832); +#28828 = CIRCLE('',#28829,1.05); +#28829 = AXIS2_PLACEMENT_2D('',#28830,#28831); +#28830 = CARTESIAN_POINT('',(1.077005151728E-10,-9.589484761818E-11)); +#28831 = DIRECTION('',(1.,8.597252304657E-32)); +#28832 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28833 = PCURVE('',#28834,#28839); +#28834 = CYLINDRICAL_SURFACE('',#28835,1.05); +#28835 = AXIS2_PLACEMENT_3D('',#28836,#28837,#28838); +#28836 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,43.5)); +#28837 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28838 = DIRECTION('',(-1.,-3.326281435446E-31,-1.153478467143E-15)); +#28839 = DEFINITIONAL_REPRESENTATION('',(#28840),#28844); +#28840 = LINE('',#28841,#28842); +#28841 = CARTESIAN_POINT('',(6.28318530718,2.)); +#28842 = VECTOR('',#28843,1.); +#28843 = DIRECTION('',(-1.,0.)); +#28844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28845 = ADVANCED_FACE('',(#28846),#28834,.F.); +#28846 = FACE_BOUND('',#28847,.F.); +#28847 = EDGE_LOOP('',(#28848,#28871,#28893,#28894)); +#28848 = ORIENTED_EDGE('',*,*,#28849,.T.); +#28849 = EDGE_CURVE('',#28818,#28850,#28852,.T.); +#28850 = VERTEX_POINT('',#28851); +#28851 = CARTESIAN_POINT('',(-28.95000000018,61.600000000096,40.)); +#28852 = SEAM_CURVE('',#28853,(#28857,#28864),.PCURVE_S1.); +#28853 = LINE('',#28854,#28855); +#28854 = CARTESIAN_POINT('',(-28.95000000018,61.600000000096,43.5)); +#28855 = VECTOR('',#28856,1.); +#28856 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#28857 = PCURVE('',#28834,#28858); +#28858 = DEFINITIONAL_REPRESENTATION('',(#28859),#28863); +#28859 = LINE('',#28860,#28861); +#28860 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28861 = VECTOR('',#28862,1.); +#28862 = DIRECTION('',(-4.440892098501E-15,1.)); +#28863 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28864 = PCURVE('',#28834,#28865); +#28865 = DEFINITIONAL_REPRESENTATION('',(#28866),#28870); +#28866 = LINE('',#28867,#28868); +#28867 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#28868 = VECTOR('',#28869,1.); +#28869 = DIRECTION('',(-4.440892098501E-15,1.)); +#28870 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28871 = ORIENTED_EDGE('',*,*,#28872,.T.); +#28872 = EDGE_CURVE('',#28850,#28850,#28873,.T.); +#28873 = SURFACE_CURVE('',#28874,(#28879,#28886),.PCURVE_S1.); +#28874 = CIRCLE('',#28875,1.05); +#28875 = AXIS2_PLACEMENT_3D('',#28876,#28877,#28878); +#28876 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,40.)); +#28877 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#28878 = DIRECTION('',(-1.,-3.198975308709E-31,-1.146036670579E-15)); +#28879 = PCURVE('',#28834,#28880); +#28880 = DEFINITIONAL_REPRESENTATION('',(#28881),#28885); +#28881 = LINE('',#28882,#28883); +#28882 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#28883 = VECTOR('',#28884,1.); +#28884 = DIRECTION('',(-1.,0.)); +#28885 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28886 = PCURVE('',#27414,#28887); +#28887 = DEFINITIONAL_REPRESENTATION('',(#28888),#28892); +#28888 = CIRCLE('',#28889,1.05); +#28889 = AXIS2_PLACEMENT_2D('',#28890,#28891); +#28890 = CARTESIAN_POINT('',(28.000000000146,-61.60000000017)); +#28891 = DIRECTION('',(1.,3.198975308709E-31)); +#28892 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28893 = ORIENTED_EDGE('',*,*,#28849,.F.); +#28894 = ORIENTED_EDGE('',*,*,#28817,.F.); +#28895 = ADVANCED_FACE('',(#28896),#28456,.F.); +#28896 = FACE_BOUND('',#28897,.F.); +#28897 = EDGE_LOOP('',(#28898,#28921,#28943,#28944)); +#28898 = ORIENTED_EDGE('',*,*,#28899,.T.); +#28899 = EDGE_CURVE('',#28440,#28900,#28902,.T.); +#28900 = VERTEX_POINT('',#28901); +#28901 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011,40.)); +#28902 = SEAM_CURVE('',#28903,(#28907,#28914),.PCURVE_S1.); +#28903 = LINE('',#28904,#28905); +#28904 = CARTESIAN_POINT('',(27.04999999993,-61.60000000011,43.5)); +#28905 = VECTOR('',#28906,1.); +#28906 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28907 = PCURVE('',#28456,#28908); +#28908 = DEFINITIONAL_REPRESENTATION('',(#28909),#28913); +#28909 = LINE('',#28910,#28911); +#28910 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28911 = VECTOR('',#28912,1.); +#28912 = DIRECTION('',(-4.440892098501E-15,1.)); +#28913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28914 = PCURVE('',#28456,#28915); +#28915 = DEFINITIONAL_REPRESENTATION('',(#28916),#28920); +#28916 = LINE('',#28917,#28918); +#28917 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#28918 = VECTOR('',#28919,1.); +#28919 = DIRECTION('',(-4.440892098501E-15,1.)); +#28920 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28921 = ORIENTED_EDGE('',*,*,#28922,.T.); +#28922 = EDGE_CURVE('',#28900,#28900,#28923,.T.); +#28923 = SURFACE_CURVE('',#28924,(#28929,#28936),.PCURVE_S1.); +#28924 = CIRCLE('',#28925,1.05); +#28925 = AXIS2_PLACEMENT_3D('',#28926,#28927,#28928); +#28926 = CARTESIAN_POINT('',(25.99999999993,-61.60000000011,40.)); +#28927 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#28928 = DIRECTION('',(-1.,3.678826534935E-31,-1.146036670579E-15)); +#28929 = PCURVE('',#28456,#28930); +#28930 = DEFINITIONAL_REPRESENTATION('',(#28931),#28935); +#28931 = LINE('',#28932,#28933); +#28932 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#28933 = VECTOR('',#28934,1.); +#28934 = DIRECTION('',(-1.,0.)); +#28935 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28936 = PCURVE('',#27414,#28937); +#28937 = DEFINITIONAL_REPRESENTATION('',(#28938),#28942); +#28938 = CIRCLE('',#28939,1.05); +#28939 = AXIS2_PLACEMENT_2D('',#28940,#28941); +#28940 = CARTESIAN_POINT('',(-27.99999999996,61.600000000031)); +#28941 = DIRECTION('',(1.,-3.678826534935E-31)); +#28942 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28943 = ORIENTED_EDGE('',*,*,#28899,.F.); +#28944 = ORIENTED_EDGE('',*,*,#28439,.F.); +#28945 = ADVANCED_FACE('',(#28946),#28582,.F.); +#28946 = FACE_BOUND('',#28947,.F.); +#28947 = EDGE_LOOP('',(#28948,#28971,#28993,#28994)); +#28948 = ORIENTED_EDGE('',*,*,#28949,.T.); +#28949 = EDGE_CURVE('',#28566,#28950,#28952,.T.); +#28950 = VERTEX_POINT('',#28951); +#28951 = CARTESIAN_POINT('',(27.050000000019,61.6,40.)); +#28952 = SEAM_CURVE('',#28953,(#28957,#28964),.PCURVE_S1.); +#28953 = LINE('',#28954,#28955); +#28954 = CARTESIAN_POINT('',(27.050000000019,61.6,43.5)); +#28955 = VECTOR('',#28956,1.); +#28956 = DIRECTION('',(-7.91599702251E-57,-2.306956934286E-15,-1.)); +#28957 = PCURVE('',#28582,#28958); +#28958 = DEFINITIONAL_REPRESENTATION('',(#28959),#28963); +#28959 = LINE('',#28960,#28961); +#28960 = CARTESIAN_POINT('',(3.14159265359,0.)); +#28961 = VECTOR('',#28962,1.); +#28962 = DIRECTION('',(-4.4408920985E-15,1.)); +#28963 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28964 = PCURVE('',#28582,#28965); +#28965 = DEFINITIONAL_REPRESENTATION('',(#28966),#28970); +#28966 = LINE('',#28967,#28968); +#28967 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#28968 = VECTOR('',#28969,1.); +#28969 = DIRECTION('',(-4.4408920985E-15,1.)); +#28970 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28971 = ORIENTED_EDGE('',*,*,#28972,.T.); +#28972 = EDGE_CURVE('',#28950,#28950,#28973,.T.); +#28973 = SURFACE_CURVE('',#28974,(#28979,#28986),.PCURVE_S1.); +#28974 = CIRCLE('',#28975,1.05); +#28975 = AXIS2_PLACEMENT_3D('',#28976,#28977,#28978); +#28976 = CARTESIAN_POINT('',(26.000000000019,61.6,40.)); +#28977 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#28978 = DIRECTION('',(-1.,3.678826534935E-31,-1.146036670579E-15)); +#28979 = PCURVE('',#28582,#28980); +#28980 = DEFINITIONAL_REPRESENTATION('',(#28981),#28985); +#28981 = LINE('',#28982,#28983); +#28982 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#28983 = VECTOR('',#28984,1.); +#28984 = DIRECTION('',(-1.,0.)); +#28985 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28986 = PCURVE('',#27414,#28987); +#28987 = DEFINITIONAL_REPRESENTATION('',(#28988),#28992); +#28988 = CIRCLE('',#28989,1.05); +#28989 = AXIS2_PLACEMENT_2D('',#28990,#28991); +#28990 = CARTESIAN_POINT('',(-28.00000000005,-61.60000000008)); +#28991 = DIRECTION('',(1.,-3.678826534935E-31)); +#28992 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#28993 = ORIENTED_EDGE('',*,*,#28949,.F.); +#28994 = ORIENTED_EDGE('',*,*,#28565,.F.); +#28995 = ADVANCED_FACE('',(#28996),#28708,.F.); +#28996 = FACE_BOUND('',#28997,.F.); +#28997 = EDGE_LOOP('',(#28998,#29021,#29043,#29044)); +#28998 = ORIENTED_EDGE('',*,*,#28999,.T.); +#28999 = EDGE_CURVE('',#28692,#29000,#29002,.T.); +#29000 = VERTEX_POINT('',#29001); +#29001 = CARTESIAN_POINT('',(-28.95000000016,-61.60000000003,40.)); +#29002 = SEAM_CURVE('',#29003,(#29007,#29014),.PCURVE_S1.); +#29003 = LINE('',#29004,#29005); +#29004 = CARTESIAN_POINT('',(-28.95000000016,-61.60000000003,43.5)); +#29005 = VECTOR('',#29006,1.); +#29006 = DIRECTION('',(1.153478467143E-15,-2.306956934286E-15,-1.)); +#29007 = PCURVE('',#28708,#29008); +#29008 = DEFINITIONAL_REPRESENTATION('',(#29009),#29013); +#29009 = LINE('',#29010,#29011); +#29010 = CARTESIAN_POINT('',(3.14159265359,0.)); +#29011 = VECTOR('',#29012,1.); +#29012 = DIRECTION('',(-4.440892098501E-15,1.)); +#29013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29014 = PCURVE('',#28708,#29015); +#29015 = DEFINITIONAL_REPRESENTATION('',(#29016),#29020); +#29016 = LINE('',#29017,#29018); +#29017 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#29018 = VECTOR('',#29019,1.); +#29019 = DIRECTION('',(-4.440892098501E-15,1.)); +#29020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29021 = ORIENTED_EDGE('',*,*,#29022,.T.); +#29022 = EDGE_CURVE('',#29000,#29000,#29023,.T.); +#29023 = SURFACE_CURVE('',#29024,(#29029,#29036),.PCURVE_S1.); +#29024 = CIRCLE('',#29025,1.05); +#29025 = AXIS2_PLACEMENT_3D('',#29026,#29027,#29028); +#29026 = CARTESIAN_POINT('',(-30.00000000016,-61.60000000003,40.)); +#29027 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29028 = DIRECTION('',(-1.,-3.198975308709E-31,-1.146036670579E-15)); +#29029 = PCURVE('',#28708,#29030); +#29030 = DEFINITIONAL_REPRESENTATION('',(#29031),#29035); +#29031 = LINE('',#29032,#29033); +#29032 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#29033 = VECTOR('',#29034,1.); +#29034 = DIRECTION('',(-1.,0.)); +#29035 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29036 = PCURVE('',#27414,#29037); +#29037 = DEFINITIONAL_REPRESENTATION('',(#29038),#29042); +#29038 = CIRCLE('',#29039,1.05); +#29039 = AXIS2_PLACEMENT_2D('',#29040,#29041); +#29040 = CARTESIAN_POINT('',(28.000000000127,61.59999999995)); +#29041 = DIRECTION('',(1.,3.198975308709E-31)); +#29042 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29043 = ORIENTED_EDGE('',*,*,#28999,.F.); +#29044 = ORIENTED_EDGE('',*,*,#28691,.F.); +#29045 = ADVANCED_FACE('',(#29046),#29061,.T.); +#29046 = FACE_BOUND('',#29047,.T.); +#29047 = EDGE_LOOP('',(#29048,#29083,#29111,#29135)); +#29048 = ORIENTED_EDGE('',*,*,#29049,.T.); +#29049 = EDGE_CURVE('',#29050,#29052,#29054,.T.); +#29050 = VERTEX_POINT('',#29051); +#29051 = CARTESIAN_POINT('',(-35.00000000018,61.600000000096,43.5)); +#29052 = VERTEX_POINT('',#29053); +#29053 = CARTESIAN_POINT('',(-30.00000000018,66.600000000096,43.5)); +#29054 = SURFACE_CURVE('',#29055,(#29060,#29072),.PCURVE_S1.); +#29055 = CIRCLE('',#29056,5.); +#29056 = AXIS2_PLACEMENT_3D('',#29057,#29058,#29059); +#29057 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,43.5)); +#29058 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29059 = DIRECTION('',(-0.707106781187,0.707106781187, + -2.020011343289E-15)); +#29060 = PCURVE('',#29061,#29066); +#29061 = CYLINDRICAL_SURFACE('',#29062,5.); +#29062 = AXIS2_PLACEMENT_3D('',#29063,#29064,#29065); +#29063 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,40.)); +#29064 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29065 = DIRECTION('',(-0.707106781187,0.707106781187, + -2.691587072029E-15)); +#29066 = DEFINITIONAL_REPRESENTATION('',(#29067),#29071); +#29067 = LINE('',#29068,#29069); +#29068 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#29069 = VECTOR('',#29070,1.); +#29070 = DIRECTION('',(-1.,4.52345554697E-15)); +#29071 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29072 = PCURVE('',#26760,#29073); +#29073 = DEFINITIONAL_REPRESENTATION('',(#29074),#29082); +#29074 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29075,#29076,#29077,#29078 + ,#29079,#29080,#29081),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29075 = CARTESIAN_POINT('',(31.535533906079,-65.13553390611)); +#29076 = CARTESIAN_POINT('',(25.411809549121,-71.25925826306)); +#29077 = CARTESIAN_POINT('',(23.170370868701,-62.89409522569)); +#29078 = CARTESIAN_POINT('',(20.928932188281,-54.52893218831)); +#29079 = CARTESIAN_POINT('',(29.294095225659,-56.77037086873)); +#29080 = CARTESIAN_POINT('',(37.659258263037,-59.01180954915)); +#29081 = CARTESIAN_POINT('',(31.535533906079,-65.13553390611)); +#29082 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29083 = ORIENTED_EDGE('',*,*,#29084,.T.); +#29084 = EDGE_CURVE('',#29052,#29085,#29087,.T.); +#29085 = VERTEX_POINT('',#29086); +#29086 = CARTESIAN_POINT('',(-30.00000000018,66.600000000096,40.)); +#29087 = SURFACE_CURVE('',#29088,(#29092,#29099),.PCURVE_S1.); +#29088 = LINE('',#29089,#29090); +#29089 = CARTESIAN_POINT('',(-30.00000000018,66.600000000096,40.)); +#29090 = VECTOR('',#29091,1.); +#29091 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29092 = PCURVE('',#29061,#29093); +#29093 = DEFINITIONAL_REPRESENTATION('',(#29094),#29098); +#29094 = LINE('',#29095,#29096); +#29095 = CARTESIAN_POINT('',(-0.785398163397,1.42108547152E-14)); +#29096 = VECTOR('',#29097,1.); +#29097 = DIRECTION('',(2.537652627715E-16,-1.)); +#29098 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29099 = PCURVE('',#29100,#29105); +#29100 = PLANE('',#29101); +#29101 = AXIS2_PLACEMENT_3D('',#29102,#29103,#29104); +#29102 = CARTESIAN_POINT('',(31.000000000111,66.600000000096,40.)); +#29103 = DIRECTION('',(2.908242968552E-30,1.,-2.537652627715E-15)); +#29104 = DIRECTION('',(-1.,-4.303988140432E-45,-1.146036670579E-15)); +#29105 = DEFINITIONAL_REPRESENTATION('',(#29106),#29110); +#29106 = LINE('',#29107,#29108); +#29107 = CARTESIAN_POINT('',(61.000000000293,-3.667317345836E-14)); +#29108 = VECTOR('',#29109,1.); +#29109 = DIRECTION('',(-1.227896432782E-16,-1.)); +#29110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29111 = ORIENTED_EDGE('',*,*,#29112,.T.); +#29112 = EDGE_CURVE('',#29085,#29113,#29115,.T.); +#29113 = VERTEX_POINT('',#29114); +#29114 = CARTESIAN_POINT('',(-35.00000000018,61.600000000096,40.)); +#29115 = SURFACE_CURVE('',#29116,(#29121,#29128),.PCURVE_S1.); +#29116 = CIRCLE('',#29117,5.); +#29117 = AXIS2_PLACEMENT_3D('',#29118,#29119,#29120); +#29118 = CARTESIAN_POINT('',(-30.00000000018,61.600000000096,40.)); +#29119 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29120 = DIRECTION('',(-0.707106781187,0.707106781187, + -2.020011343289E-15)); +#29121 = PCURVE('',#29061,#29122); +#29122 = DEFINITIONAL_REPRESENTATION('',(#29123),#29127); +#29123 = LINE('',#29124,#29125); +#29124 = CARTESIAN_POINT('',(-6.28318530718,3.19744231092E-14)); +#29125 = VECTOR('',#29126,1.); +#29126 = DIRECTION('',(1.,-4.52345554697E-15)); +#29127 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29128 = PCURVE('',#27414,#29129); +#29129 = DEFINITIONAL_REPRESENTATION('',(#29130),#29134); +#29130 = CIRCLE('',#29131,5.); +#29131 = AXIS2_PLACEMENT_2D('',#29132,#29133); +#29132 = CARTESIAN_POINT('',(28.000000000146,-61.60000000017)); +#29133 = DIRECTION('',(0.707106781187,-0.707106781187)); +#29134 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29135 = ORIENTED_EDGE('',*,*,#29136,.T.); +#29136 = EDGE_CURVE('',#29113,#29050,#29137,.T.); +#29137 = SURFACE_CURVE('',#29138,(#29142,#29149),.PCURVE_S1.); +#29138 = LINE('',#29139,#29140); +#29139 = CARTESIAN_POINT('',(-35.00000000018,61.600000000096,40.)); +#29140 = VECTOR('',#29141,1.); +#29141 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29142 = PCURVE('',#29061,#29143); +#29143 = DEFINITIONAL_REPRESENTATION('',(#29144),#29148); +#29144 = LINE('',#29145,#29146); +#29145 = CARTESIAN_POINT('',(0.785398163397,7.105427357601E-15)); +#29146 = VECTOR('',#29147,1.); +#29147 = DIRECTION('',(2.854859206179E-16,1.)); +#29148 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29149 = PCURVE('',#29150,#29155); +#29150 = PLANE('',#29151); +#29151 = AXIS2_PLACEMENT_3D('',#29152,#29153,#29154); +#29152 = CARTESIAN_POINT('',(-35.00000000018,66.600000000096,40.)); +#29153 = DIRECTION('',(-1.,8.881784196966E-17,-1.268826313857E-15)); +#29154 = DIRECTION('',(-8.881784196966E-17,-1.,1.710690767248E-15)); +#29155 = DEFINITIONAL_REPRESENTATION('',(#29156),#29160); +#29156 = LINE('',#29157,#29158); +#29157 = CARTESIAN_POINT('',(5.,-8.55345383624E-15)); +#29158 = VECTOR('',#29159,1.); +#29159 = DIRECTION('',(-8.269618604667E-16,1.)); +#29160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29161 = ADVANCED_FACE('',(#29162),#29150,.T.); +#29162 = FACE_BOUND('',#29163,.T.); +#29163 = EDGE_LOOP('',(#29164,#29165,#29188,#29216)); +#29164 = ORIENTED_EDGE('',*,*,#29136,.F.); +#29165 = ORIENTED_EDGE('',*,*,#29166,.T.); +#29166 = EDGE_CURVE('',#29113,#29167,#29169,.T.); +#29167 = VERTEX_POINT('',#29168); +#29168 = CARTESIAN_POINT('',(-35.00000000018,46.157989557691,40.)); +#29169 = SURFACE_CURVE('',#29170,(#29174,#29181),.PCURVE_S1.); +#29170 = LINE('',#29171,#29172); +#29171 = CARTESIAN_POINT('',(-35.00000000018,66.600000000096,40.)); +#29172 = VECTOR('',#29173,1.); +#29173 = DIRECTION('',(-8.881784196966E-17,-1.,1.710690767248E-15)); +#29174 = PCURVE('',#29150,#29175); +#29175 = DEFINITIONAL_REPRESENTATION('',(#29176),#29180); +#29176 = LINE('',#29177,#29178); +#29177 = CARTESIAN_POINT('',(0.,0.)); +#29178 = VECTOR('',#29179,1.); +#29179 = DIRECTION('',(1.,0.)); +#29180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29181 = PCURVE('',#27414,#29182); +#29182 = DEFINITIONAL_REPRESENTATION('',(#29183),#29187); +#29183 = LINE('',#29184,#29185); +#29184 = CARTESIAN_POINT('',(33.000000000146,-66.60000000017)); +#29185 = VECTOR('',#29186,1.); +#29186 = DIRECTION('',(8.881784196966E-17,1.)); +#29187 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29188 = ORIENTED_EDGE('',*,*,#29189,.F.); +#29189 = EDGE_CURVE('',#29190,#29167,#29192,.T.); +#29190 = VERTEX_POINT('',#29191); +#29191 = CARTESIAN_POINT('',(-35.00000000018,46.157989557691,43.5)); +#29192 = SURFACE_CURVE('',#29193,(#29197,#29204),.PCURVE_S1.); +#29193 = LINE('',#29194,#29195); +#29194 = CARTESIAN_POINT('',(-35.00000000018,46.157989557691,40.)); +#29195 = VECTOR('',#29196,1.); +#29196 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29197 = PCURVE('',#29150,#29198); +#29198 = DEFINITIONAL_REPRESENTATION('',(#29199),#29203); +#29199 = LINE('',#29200,#29201); +#29200 = CARTESIAN_POINT('',(20.442010442405,-3.496995852781E-14)); +#29201 = VECTOR('',#29202,1.); +#29202 = DIRECTION('',(8.269618604667E-16,-1.)); +#29203 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29204 = PCURVE('',#29205,#29210); +#29205 = CYLINDRICAL_SURFACE('',#29206,20.); +#29206 = AXIS2_PLACEMENT_3D('',#29207,#29208,#29209); +#29207 = CARTESIAN_POINT('',(-15.00000000018,46.157989557691,40.)); +#29208 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29209 = DIRECTION('',(-0.977327073645,-0.211735191032, + -7.027479443835E-16)); +#29210 = DEFINITIONAL_REPRESENTATION('',(#29211),#29215); +#29211 = LINE('',#29212,#29213); +#29212 = CARTESIAN_POINT('',(6.069835242238,-8.526512829121E-14)); +#29213 = VECTOR('',#29214,1.); +#29214 = DIRECTION('',(0.,-1.)); +#29215 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29216 = ORIENTED_EDGE('',*,*,#29217,.F.); +#29217 = EDGE_CURVE('',#29050,#29190,#29218,.T.); +#29218 = SURFACE_CURVE('',#29219,(#29223,#29230),.PCURVE_S1.); +#29219 = LINE('',#29220,#29221); +#29220 = CARTESIAN_POINT('',(-35.00000000018,66.600000000096,43.5)); +#29221 = VECTOR('',#29222,1.); +#29222 = DIRECTION('',(-8.881784196966E-17,-1.,1.710690767248E-15)); +#29223 = PCURVE('',#29150,#29224); +#29224 = DEFINITIONAL_REPRESENTATION('',(#29225),#29229); +#29225 = LINE('',#29226,#29227); +#29226 = CARTESIAN_POINT('',(5.987417685368E-15,3.5)); +#29227 = VECTOR('',#29228,1.); +#29228 = DIRECTION('',(1.,0.)); +#29229 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29230 = PCURVE('',#26760,#29231); +#29231 = DEFINITIONAL_REPRESENTATION('',(#29232),#29236); +#29232 = LINE('',#29233,#29234); +#29233 = CARTESIAN_POINT('',(33.000000000146,-66.60000000017)); +#29234 = VECTOR('',#29235,1.); +#29235 = DIRECTION('',(8.881784196966E-17,1.)); +#29236 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29237 = ADVANCED_FACE('',(#29238,#29516,#29519,#29522,#29525,#29528, + #29531,#29534,#29537,#29543,#29546),#27414,.F.); +#29238 = FACE_BOUND('',#29239,.T.); +#29239 = EDGE_LOOP('',(#29240,#29241,#29264,#29293,#29321,#29350,#29378, + #29407,#29435,#29464,#29493,#29515)); +#29240 = ORIENTED_EDGE('',*,*,#29112,.F.); +#29241 = ORIENTED_EDGE('',*,*,#29242,.F.); +#29242 = EDGE_CURVE('',#29243,#29085,#29245,.T.); +#29243 = VERTEX_POINT('',#29244); +#29244 = CARTESIAN_POINT('',(26.000000000111,66.600000000096,40.)); +#29245 = SURFACE_CURVE('',#29246,(#29250,#29257),.PCURVE_S1.); +#29246 = LINE('',#29247,#29248); +#29247 = CARTESIAN_POINT('',(31.000000000111,66.600000000096,40.)); +#29248 = VECTOR('',#29249,1.); +#29249 = DIRECTION('',(-1.,1.45092644297E-114,-1.146036670579E-15)); +#29250 = PCURVE('',#27414,#29251); +#29251 = DEFINITIONAL_REPRESENTATION('',(#29252),#29256); +#29252 = LINE('',#29253,#29254); +#29253 = CARTESIAN_POINT('',(-33.00000000014,-66.60000000017)); +#29254 = VECTOR('',#29255,1.); +#29255 = DIRECTION('',(1.,-1.308603298716E-46)); +#29256 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29257 = PCURVE('',#29100,#29258); +#29258 = DEFINITIONAL_REPRESENTATION('',(#29259),#29263); +#29259 = LINE('',#29260,#29261); +#29260 = CARTESIAN_POINT('',(-0.,0.)); +#29261 = VECTOR('',#29262,1.); +#29262 = DIRECTION('',(1.,0.)); +#29263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29264 = ORIENTED_EDGE('',*,*,#29265,.F.); +#29265 = EDGE_CURVE('',#29266,#29243,#29268,.T.); +#29266 = VERTEX_POINT('',#29267); +#29267 = CARTESIAN_POINT('',(31.000000000111,61.600000000096,40.)); +#29268 = SURFACE_CURVE('',#29269,(#29274,#29281),.PCURVE_S1.); +#29269 = CIRCLE('',#29270,5.); +#29270 = AXIS2_PLACEMENT_3D('',#29271,#29272,#29273); +#29271 = CARTESIAN_POINT('',(26.000000000111,61.600000000096,40.)); +#29272 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29273 = DIRECTION('',(0.707106781187,0.707106781187,-3.992707407793E-16 + )); +#29274 = PCURVE('',#27414,#29275); +#29275 = DEFINITIONAL_REPRESENTATION('',(#29276),#29280); +#29276 = CIRCLE('',#29277,5.); +#29277 = AXIS2_PLACEMENT_2D('',#29278,#29279); +#29278 = CARTESIAN_POINT('',(-28.00000000014,-61.60000000017)); +#29279 = DIRECTION('',(-0.707106781187,-0.707106781187)); +#29280 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29281 = PCURVE('',#29282,#29287); +#29282 = CYLINDRICAL_SURFACE('',#29283,5.); +#29283 = AXIS2_PLACEMENT_3D('',#29284,#29285,#29286); +#29284 = CARTESIAN_POINT('',(26.000000000111,61.600000000096,40.)); +#29285 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29286 = DIRECTION('',(0.707106781187,0.707106781187,-8.971956906764E-16 + )); +#29287 = DEFINITIONAL_REPRESENTATION('',(#29288),#29292); +#29288 = LINE('',#29289,#29290); +#29289 = CARTESIAN_POINT('',(0.,-2.48689957516E-14)); +#29290 = VECTOR('',#29291,1.); +#29291 = DIRECTION('',(1.,4.52345554697E-15)); +#29292 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29293 = ORIENTED_EDGE('',*,*,#29294,.F.); +#29294 = EDGE_CURVE('',#29295,#29266,#29297,.T.); +#29295 = VERTEX_POINT('',#29296); +#29296 = CARTESIAN_POINT('',(31.000000000111,-61.60000000026,40.)); +#29297 = SURFACE_CURVE('',#29298,(#29302,#29309),.PCURVE_S1.); +#29298 = LINE('',#29299,#29300); +#29299 = CARTESIAN_POINT('',(31.000000000111,-66.60000000026,40.)); +#29300 = VECTOR('',#29301,1.); +#29301 = DIRECTION('',(1.960514351287E-30,1.,-1.710690767248E-15)); +#29302 = PCURVE('',#27414,#29303); +#29303 = DEFINITIONAL_REPRESENTATION('',(#29304),#29308); +#29304 = LINE('',#29305,#29306); +#29305 = CARTESIAN_POINT('',(-33.00000000014,66.600000000178)); +#29306 = VECTOR('',#29307,1.); +#29307 = DIRECTION('',(-1.971087366616E-45,-1.)); +#29308 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29309 = PCURVE('',#29310,#29315); +#29310 = PLANE('',#29311); +#29311 = AXIS2_PLACEMENT_3D('',#29312,#29313,#29314); +#29312 = CARTESIAN_POINT('',(31.000000000111,-66.60000000026,40.)); +#29313 = DIRECTION('',(1.,2.100551090698E-31,1.268826313857E-15)); +#29314 = DIRECTION('',(1.960514351287E-30,1.,-1.710690767248E-15)); +#29315 = DEFINITIONAL_REPRESENTATION('',(#29316),#29320); +#29316 = LINE('',#29317,#29318); +#29317 = CARTESIAN_POINT('',(0.,0.)); +#29318 = VECTOR('',#29319,1.); +#29319 = DIRECTION('',(1.,0.)); +#29320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29321 = ORIENTED_EDGE('',*,*,#29322,.F.); +#29322 = EDGE_CURVE('',#29323,#29295,#29325,.T.); +#29323 = VERTEX_POINT('',#29324); +#29324 = CARTESIAN_POINT('',(26.000000000111,-66.60000000026,40.)); +#29325 = SURFACE_CURVE('',#29326,(#29331,#29338),.PCURVE_S1.); +#29326 = CIRCLE('',#29327,5.); +#29327 = AXIS2_PLACEMENT_3D('',#29328,#29329,#29330); +#29328 = CARTESIAN_POINT('',(26.000000000111,-61.60000000026,40.)); +#29329 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29330 = DIRECTION('',(0.707106781187,-0.707106781187,2.020011343289E-15 + )); +#29331 = PCURVE('',#27414,#29332); +#29332 = DEFINITIONAL_REPRESENTATION('',(#29333),#29337); +#29333 = CIRCLE('',#29334,5.); +#29334 = AXIS2_PLACEMENT_2D('',#29335,#29336); +#29335 = CARTESIAN_POINT('',(-28.00000000014,61.600000000178)); +#29336 = DIRECTION('',(-0.707106781187,0.707106781187)); +#29337 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29338 = PCURVE('',#29339,#29344); +#29339 = CYLINDRICAL_SURFACE('',#29340,5.); +#29340 = AXIS2_PLACEMENT_3D('',#29341,#29342,#29343); +#29341 = CARTESIAN_POINT('',(26.000000000111,-61.60000000026,40.)); +#29342 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29343 = DIRECTION('',(0.707106781187,-0.707106781187,2.691587072029E-15 + )); +#29344 = DEFINITIONAL_REPRESENTATION('',(#29345),#29349); +#29345 = LINE('',#29346,#29347); +#29346 = CARTESIAN_POINT('',(-6.28318530718,6.750155989721E-14)); +#29347 = VECTOR('',#29348,1.); +#29348 = DIRECTION('',(1.,4.52345554697E-15)); +#29349 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29350 = ORIENTED_EDGE('',*,*,#29351,.F.); +#29351 = EDGE_CURVE('',#29352,#29323,#29354,.T.); +#29352 = VERTEX_POINT('',#29353); +#29353 = CARTESIAN_POINT('',(-30.00000000007,-66.60000000026,40.)); +#29354 = SURFACE_CURVE('',#29355,(#29359,#29366),.PCURVE_S1.); +#29355 = LINE('',#29356,#29357); +#29356 = CARTESIAN_POINT('',(-35.00000000007,-66.60000000026,40.)); +#29357 = VECTOR('',#29358,1.); +#29358 = DIRECTION('',(1.,-1.45092644297E-114,1.146036670579E-15)); +#29359 = PCURVE('',#27414,#29360); +#29360 = DEFINITIONAL_REPRESENTATION('',(#29361),#29365); +#29361 = LINE('',#29362,#29363); +#29362 = CARTESIAN_POINT('',(33.000000000043,66.600000000178)); +#29363 = VECTOR('',#29364,1.); +#29364 = DIRECTION('',(-1.,1.308603298716E-46)); +#29365 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29366 = PCURVE('',#29367,#29372); +#29367 = PLANE('',#29368); +#29368 = AXIS2_PLACEMENT_3D('',#29369,#29370,#29371); +#29369 = CARTESIAN_POINT('',(-35.00000000007,-66.60000000026,40.)); +#29370 = DIRECTION('',(-2.908242968552E-30,-1.,2.537652627715E-15)); +#29371 = DIRECTION('',(1.,4.303988140432E-45,1.146036670579E-15)); +#29372 = DEFINITIONAL_REPRESENTATION('',(#29373),#29377); +#29373 = LINE('',#29374,#29375); +#29374 = CARTESIAN_POINT('',(0.,0.)); +#29375 = VECTOR('',#29376,1.); +#29376 = DIRECTION('',(1.,0.)); +#29377 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29378 = ORIENTED_EDGE('',*,*,#29379,.F.); +#29379 = EDGE_CURVE('',#29380,#29352,#29382,.T.); +#29380 = VERTEX_POINT('',#29381); +#29381 = CARTESIAN_POINT('',(-35.00000000007,-61.60000000026,40.)); +#29382 = SURFACE_CURVE('',#29383,(#29388,#29395),.PCURVE_S1.); +#29383 = CIRCLE('',#29384,5.); +#29384 = AXIS2_PLACEMENT_3D('',#29385,#29386,#29387); +#29385 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,40.)); +#29386 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29387 = DIRECTION('',(-0.707106781187,-0.707106781187, + 3.992707407793E-16)); +#29388 = PCURVE('',#27414,#29389); +#29389 = DEFINITIONAL_REPRESENTATION('',(#29390),#29394); +#29390 = CIRCLE('',#29391,5.); +#29391 = AXIS2_PLACEMENT_2D('',#29392,#29393); +#29392 = CARTESIAN_POINT('',(28.000000000043,61.600000000178)); +#29393 = DIRECTION('',(0.707106781187,0.707106781187)); +#29394 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29395 = PCURVE('',#29396,#29401); +#29396 = CYLINDRICAL_SURFACE('',#29397,5.); +#29397 = AXIS2_PLACEMENT_3D('',#29398,#29399,#29400); +#29398 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,40.)); +#29399 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29400 = DIRECTION('',(-0.707106781187,-0.707106781187, + 8.971956906764E-16)); +#29401 = DEFINITIONAL_REPRESENTATION('',(#29402),#29406); +#29402 = LINE('',#29403,#29404); +#29403 = CARTESIAN_POINT('',(-6.28318530718,2.48689957516E-14)); +#29404 = VECTOR('',#29405,1.); +#29405 = DIRECTION('',(1.,-4.52345554697E-15)); +#29406 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29407 = ORIENTED_EDGE('',*,*,#29408,.T.); +#29408 = EDGE_CURVE('',#29380,#29409,#29411,.T.); +#29409 = VERTEX_POINT('',#29410); +#29410 = CARTESIAN_POINT('',(-35.00000000007,-46.1579895577,40.)); +#29411 = SURFACE_CURVE('',#29412,(#29416,#29423),.PCURVE_S1.); +#29412 = LINE('',#29413,#29414); +#29413 = CARTESIAN_POINT('',(-35.00000000007,-66.60000000026,40.)); +#29414 = VECTOR('',#29415,1.); +#29415 = DIRECTION('',(8.881784196922E-17,1.,-1.710690767248E-15)); +#29416 = PCURVE('',#27414,#29417); +#29417 = DEFINITIONAL_REPRESENTATION('',(#29418),#29422); +#29418 = LINE('',#29419,#29420); +#29419 = CARTESIAN_POINT('',(33.000000000043,66.600000000178)); +#29420 = VECTOR('',#29421,1.); +#29421 = DIRECTION('',(-8.881784196922E-17,-1.)); +#29422 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29423 = PCURVE('',#29424,#29429); +#29424 = PLANE('',#29425); +#29425 = AXIS2_PLACEMENT_3D('',#29426,#29427,#29428); +#29426 = CARTESIAN_POINT('',(-35.00000000007,-41.60000000003,40.)); +#29427 = DIRECTION('',(-1.,8.881784196922E-17,-1.268826313857E-15)); +#29428 = DIRECTION('',(-8.881784196922E-17,-1.,1.710690767248E-15)); +#29429 = DEFINITIONAL_REPRESENTATION('',(#29430),#29434); +#29430 = LINE('',#29431,#29432); +#29431 = CARTESIAN_POINT('',(25.000000000224,5.670871382483E-14)); +#29432 = VECTOR('',#29433,1.); +#29433 = DIRECTION('',(-1.,0.)); +#29434 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29435 = ORIENTED_EDGE('',*,*,#29436,.F.); +#29436 = EDGE_CURVE('',#29437,#29409,#29439,.T.); +#29437 = VERTEX_POINT('',#29438); +#29438 = CARTESIAN_POINT('',(-33.20672835524,-37.88060817219,40.)); +#29439 = SURFACE_CURVE('',#29440,(#29445,#29452),.PCURVE_S1.); +#29440 = CIRCLE('',#29441,20.); +#29441 = AXIS2_PLACEMENT_3D('',#29442,#29443,#29444); +#29442 = CARTESIAN_POINT('',(-15.00000000007,-46.1579895577,40.)); +#29443 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29444 = DIRECTION('',(-0.977327073645,0.211735191031, + -1.482266101945E-15)); +#29445 = PCURVE('',#27414,#29446); +#29446 = DEFINITIONAL_REPRESENTATION('',(#29447),#29451); +#29447 = CIRCLE('',#29448,20.); +#29448 = AXIS2_PLACEMENT_2D('',#29449,#29450); +#29449 = CARTESIAN_POINT('',(13.000000000043,46.157989557625)); +#29450 = DIRECTION('',(0.977327073645,-0.211735191031)); +#29451 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29452 = PCURVE('',#29453,#29458); +#29453 = CYLINDRICAL_SURFACE('',#29454,20.); +#29454 = AXIS2_PLACEMENT_3D('',#29455,#29456,#29457); +#29455 = CARTESIAN_POINT('',(-15.00000000007,-46.1579895577,40.)); +#29456 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29457 = DIRECTION('',(-0.977327073645,0.211735191031, + -1.777368672185E-15)); +#29458 = DEFINITIONAL_REPRESENTATION('',(#29459),#29463); +#29459 = LINE('',#29460,#29461); +#29460 = CARTESIAN_POINT('',(-8.881784197001E-16,1.081805627187E-13)); +#29461 = VECTOR('',#29462,1.); +#29462 = DIRECTION('',(1.,-1.665203935977E-14)); +#29463 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29464 = ORIENTED_EDGE('',*,*,#29465,.T.); +#29465 = EDGE_CURVE('',#29437,#29466,#29468,.T.); +#29466 = VERTEX_POINT('',#29467); +#29467 = CARTESIAN_POINT('',(-33.20672835532,37.880608172138,40.)); +#29468 = SURFACE_CURVE('',#29469,(#29474,#29481),.PCURVE_S1.); +#29469 = CIRCLE('',#29470,91.527999998584); +#29470 = AXIS2_PLACEMENT_3D('',#29471,#29472,#29473); +#29471 = CARTESIAN_POINT('',(-116.5279999985,-1.217745012006E-10,40.)); +#29472 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29473 = DIRECTION('',(0.890743816097,-0.45450572503,1.798343824809E-15) + ); +#29474 = PCURVE('',#27414,#29475); +#29475 = DEFINITIONAL_REPRESENTATION('',(#29476),#29480); +#29476 = CIRCLE('',#29477,91.527999998584); +#29477 = AXIS2_PLACEMENT_2D('',#29478,#29479); +#29478 = CARTESIAN_POINT('',(114.52799999849,3.945504766715E-11)); +#29479 = DIRECTION('',(-0.890743816097,0.45450572503)); +#29480 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29481 = PCURVE('',#29482,#29487); +#29482 = CYLINDRICAL_SURFACE('',#29483,91.527999998584); +#29483 = AXIS2_PLACEMENT_3D('',#29484,#29485,#29486); +#29484 = CARTESIAN_POINT('',(-116.5279999985,-1.217745012006E-10,40.)); +#29485 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29486 = DIRECTION('',(0.890743816097,-0.45450572503,2.283576840203E-15) + ); +#29487 = DEFINITIONAL_REPRESENTATION('',(#29488),#29492); +#29488 = LINE('',#29489,#29490); +#29489 = CARTESIAN_POINT('',(5.551115123126E-17,-3.853230397192E-14)); +#29490 = VECTOR('',#29491,1.); +#29491 = DIRECTION('',(1.,6.660815743892E-14)); +#29492 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29493 = ORIENTED_EDGE('',*,*,#29494,.F.); +#29494 = EDGE_CURVE('',#29167,#29466,#29495,.T.); +#29495 = SURFACE_CURVE('',#29496,(#29501,#29508),.PCURVE_S1.); +#29496 = CIRCLE('',#29497,20.); +#29497 = AXIS2_PLACEMENT_3D('',#29498,#29499,#29500); +#29498 = CARTESIAN_POINT('',(-15.00000000018,46.157989557691,40.)); +#29499 = DIRECTION('',(-1.146036670579E-15,1.710690767248E-15,1.)); +#29500 = DIRECTION('',(-0.977327073645,-0.211735191032, + -7.578392291466E-16)); +#29501 = PCURVE('',#27414,#29502); +#29502 = DEFINITIONAL_REPRESENTATION('',(#29503),#29507); +#29503 = CIRCLE('',#29504,20.); +#29504 = AXIS2_PLACEMENT_2D('',#29505,#29506); +#29505 = CARTESIAN_POINT('',(13.000000000146,-46.15798955777)); +#29506 = DIRECTION('',(0.977327073645,0.211735191032)); +#29507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29508 = PCURVE('',#29205,#29509); +#29509 = DEFINITIONAL_REPRESENTATION('',(#29510),#29514); +#29510 = LINE('',#29511,#29512); +#29511 = CARTESIAN_POINT('',(-8.881784197001E-16,-5.506275003466E-15)); +#29512 = VECTOR('',#29513,1.); +#29513 = DIRECTION('',(1.,-1.665203935969E-14)); +#29514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29515 = ORIENTED_EDGE('',*,*,#29166,.F.); +#29516 = FACE_BOUND('',#29517,.T.); +#29517 = EDGE_LOOP('',(#29518)); +#29518 = ORIENTED_EDGE('',*,*,#27800,.T.); +#29519 = FACE_BOUND('',#29520,.T.); +#29520 = EDGE_LOOP('',(#29521)); +#29521 = ORIENTED_EDGE('',*,*,#27850,.T.); +#29522 = FACE_BOUND('',#29523,.T.); +#29523 = EDGE_LOOP('',(#29524)); +#29524 = ORIENTED_EDGE('',*,*,#29022,.T.); +#29525 = FACE_BOUND('',#29526,.T.); +#29526 = EDGE_LOOP('',(#29527)); +#29527 = ORIENTED_EDGE('',*,*,#28972,.T.); +#29528 = FACE_BOUND('',#29529,.T.); +#29529 = EDGE_LOOP('',(#29530)); +#29530 = ORIENTED_EDGE('',*,*,#28922,.T.); +#29531 = FACE_BOUND('',#29532,.T.); +#29532 = EDGE_LOOP('',(#29533)); +#29533 = ORIENTED_EDGE('',*,*,#28872,.T.); +#29534 = FACE_BOUND('',#29535,.T.); +#29535 = EDGE_LOOP('',(#29536)); +#29536 = ORIENTED_EDGE('',*,*,#28293,.T.); +#29537 = FACE_BOUND('',#29538,.T.); +#29538 = EDGE_LOOP('',(#29539,#29540,#29541,#29542)); +#29539 = ORIENTED_EDGE('',*,*,#27959,.T.); +#29540 = ORIENTED_EDGE('',*,*,#28069,.T.); +#29541 = ORIENTED_EDGE('',*,*,#28145,.T.); +#29542 = ORIENTED_EDGE('',*,*,#28216,.T.); +#29543 = FACE_BOUND('',#29544,.T.); +#29544 = EDGE_LOOP('',(#29545)); +#29545 = ORIENTED_EDGE('',*,*,#27907,.T.); +#29546 = FACE_BOUND('',#29547,.T.); +#29547 = EDGE_LOOP('',(#29548)); +#29548 = ORIENTED_EDGE('',*,*,#27399,.T.); +#29549 = ADVANCED_FACE('',(#29550),#29282,.T.); +#29550 = FACE_BOUND('',#29551,.T.); +#29551 = EDGE_LOOP('',(#29552,#29582,#29603,#29604)); +#29552 = ORIENTED_EDGE('',*,*,#29553,.T.); +#29553 = EDGE_CURVE('',#29554,#29556,#29558,.T.); +#29554 = VERTEX_POINT('',#29555); +#29555 = CARTESIAN_POINT('',(26.000000000111,66.600000000096,43.5)); +#29556 = VERTEX_POINT('',#29557); +#29557 = CARTESIAN_POINT('',(31.000000000111,61.600000000096,43.5)); +#29558 = SURFACE_CURVE('',#29559,(#29564,#29571),.PCURVE_S1.); +#29559 = CIRCLE('',#29560,5.); +#29560 = AXIS2_PLACEMENT_3D('',#29561,#29562,#29563); +#29561 = CARTESIAN_POINT('',(26.000000000111,61.600000000096,43.5)); +#29562 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29563 = DIRECTION('',(0.707106781187,0.707106781187,-3.992707407793E-16 + )); +#29564 = PCURVE('',#29282,#29565); +#29565 = DEFINITIONAL_REPRESENTATION('',(#29566),#29570); +#29566 = LINE('',#29567,#29568); +#29567 = CARTESIAN_POINT('',(12.566370614359,3.5)); +#29568 = VECTOR('',#29569,1.); +#29569 = DIRECTION('',(-1.,-4.52345554697E-15)); +#29570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29571 = PCURVE('',#26760,#29572); +#29572 = DEFINITIONAL_REPRESENTATION('',(#29573),#29581); +#29573 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29574,#29575,#29576,#29577 + ,#29578,#29579,#29580),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29574 = CARTESIAN_POINT('',(-31.53553390607,-65.13553390611)); +#29575 = CARTESIAN_POINT('',(-37.65925826303,-59.01180954915)); +#29576 = CARTESIAN_POINT('',(-29.29409522565,-56.77037086873)); +#29577 = CARTESIAN_POINT('',(-20.92893218828,-54.52893218831)); +#29578 = CARTESIAN_POINT('',(-23.1703708687,-62.89409522569)); +#29579 = CARTESIAN_POINT('',(-25.41180954912,-71.25925826306)); +#29580 = CARTESIAN_POINT('',(-31.53553390607,-65.13553390611)); +#29581 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29582 = ORIENTED_EDGE('',*,*,#29583,.T.); +#29583 = EDGE_CURVE('',#29556,#29266,#29584,.T.); +#29584 = SURFACE_CURVE('',#29585,(#29589,#29596),.PCURVE_S1.); +#29585 = LINE('',#29586,#29587); +#29586 = CARTESIAN_POINT('',(31.000000000111,61.600000000096,40.)); +#29587 = VECTOR('',#29588,1.); +#29588 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29589 = PCURVE('',#29282,#29590); +#29590 = DEFINITIONAL_REPRESENTATION('',(#29591),#29595); +#29591 = LINE('',#29592,#29593); +#29592 = CARTESIAN_POINT('',(5.497787143782,-7.105427357601E-15)); +#29593 = VECTOR('',#29594,1.); +#29594 = DIRECTION('',(5.075305255429E-16,-1.)); +#29595 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29596 = PCURVE('',#29310,#29597); +#29597 = DEFINITIONAL_REPRESENTATION('',(#29598),#29602); +#29598 = LINE('',#29599,#29600); +#29599 = CARTESIAN_POINT('',(128.20000000035,2.035859034896E-14)); +#29600 = VECTOR('',#29601,1.); +#29601 = DIRECTION('',(-8.269618604667E-16,-1.)); +#29602 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29603 = ORIENTED_EDGE('',*,*,#29265,.T.); +#29604 = ORIENTED_EDGE('',*,*,#29605,.T.); +#29605 = EDGE_CURVE('',#29243,#29554,#29606,.T.); +#29606 = SURFACE_CURVE('',#29607,(#29611,#29618),.PCURVE_S1.); +#29607 = LINE('',#29608,#29609); +#29608 = CARTESIAN_POINT('',(26.000000000111,66.600000000096,40.)); +#29609 = VECTOR('',#29610,1.); +#29610 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29611 = PCURVE('',#29282,#29612); +#29612 = DEFINITIONAL_REPRESENTATION('',(#29613),#29617); +#29613 = LINE('',#29614,#29615); +#29614 = CARTESIAN_POINT('',(7.068583470577,-9.237055564881E-14)); +#29615 = VECTOR('',#29616,1.); +#29616 = DIRECTION('',(-6.661338147751E-16,1.)); +#29617 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29618 = PCURVE('',#29100,#29619); +#29619 = DEFINITIONAL_REPRESENTATION('',(#29620),#29624); +#29620 = LINE('',#29621,#29622); +#29621 = CARTESIAN_POINT('',(5.,-1.008512270111E-13)); +#29622 = VECTOR('',#29623,1.); +#29623 = DIRECTION('',(1.227896432782E-16,1.)); +#29624 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29625 = ADVANCED_FACE('',(#29626),#29310,.T.); +#29626 = FACE_BOUND('',#29627,.T.); +#29627 = EDGE_LOOP('',(#29628,#29629,#29652,#29673)); +#29628 = ORIENTED_EDGE('',*,*,#29583,.F.); +#29629 = ORIENTED_EDGE('',*,*,#29630,.F.); +#29630 = EDGE_CURVE('',#29631,#29556,#29633,.T.); +#29631 = VERTEX_POINT('',#29632); +#29632 = CARTESIAN_POINT('',(31.000000000111,-61.60000000026,43.5)); +#29633 = SURFACE_CURVE('',#29634,(#29638,#29645),.PCURVE_S1.); +#29634 = LINE('',#29635,#29636); +#29635 = CARTESIAN_POINT('',(31.000000000111,-66.60000000026,43.5)); +#29636 = VECTOR('',#29637,1.); +#29637 = DIRECTION('',(1.960514351287E-30,1.,-1.710690767248E-15)); +#29638 = PCURVE('',#29310,#29639); +#29639 = DEFINITIONAL_REPRESENTATION('',(#29640),#29644); +#29640 = LINE('',#29641,#29642); +#29641 = CARTESIAN_POINT('',(-5.987417685368E-15,3.5)); +#29642 = VECTOR('',#29643,1.); +#29643 = DIRECTION('',(1.,0.)); +#29644 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29645 = PCURVE('',#26760,#29646); +#29646 = DEFINITIONAL_REPRESENTATION('',(#29647),#29651); +#29647 = LINE('',#29648,#29649); +#29648 = CARTESIAN_POINT('',(-33.00000000014,66.600000000178)); +#29649 = VECTOR('',#29650,1.); +#29650 = DIRECTION('',(-1.971087366616E-45,-1.)); +#29651 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29652 = ORIENTED_EDGE('',*,*,#29653,.F.); +#29653 = EDGE_CURVE('',#29295,#29631,#29654,.T.); +#29654 = SURFACE_CURVE('',#29655,(#29659,#29666),.PCURVE_S1.); +#29655 = LINE('',#29656,#29657); +#29656 = CARTESIAN_POINT('',(31.000000000111,-61.60000000026,40.)); +#29657 = VECTOR('',#29658,1.); +#29658 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29659 = PCURVE('',#29310,#29660); +#29660 = DEFINITIONAL_REPRESENTATION('',(#29661),#29665); +#29661 = LINE('',#29662,#29663); +#29662 = CARTESIAN_POINT('',(5.,8.55345383624E-15)); +#29663 = VECTOR('',#29664,1.); +#29664 = DIRECTION('',(8.269618604667E-16,1.)); +#29665 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29666 = PCURVE('',#29339,#29667); +#29667 = DEFINITIONAL_REPRESENTATION('',(#29668),#29672); +#29668 = LINE('',#29669,#29670); +#29669 = CARTESIAN_POINT('',(0.785398163397,-7.105427357601E-15)); +#29670 = VECTOR('',#29671,1.); +#29671 = DIRECTION('',(1.586032892322E-16,1.)); +#29672 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29673 = ORIENTED_EDGE('',*,*,#29294,.T.); +#29674 = ADVANCED_FACE('',(#29675),#29339,.T.); +#29675 = FACE_BOUND('',#29676,.T.); +#29676 = EDGE_LOOP('',(#29677,#29705,#29726,#29727)); +#29677 = ORIENTED_EDGE('',*,*,#29678,.T.); +#29678 = EDGE_CURVE('',#29631,#29679,#29681,.T.); +#29679 = VERTEX_POINT('',#29680); +#29680 = CARTESIAN_POINT('',(26.000000000111,-66.60000000026,43.5)); +#29681 = SURFACE_CURVE('',#29682,(#29687,#29694),.PCURVE_S1.); +#29682 = CIRCLE('',#29683,5.); +#29683 = AXIS2_PLACEMENT_3D('',#29684,#29685,#29686); +#29684 = CARTESIAN_POINT('',(26.000000000111,-61.60000000026,43.5)); +#29685 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29686 = DIRECTION('',(0.707106781187,-0.707106781187,2.020011343289E-15 + )); +#29687 = PCURVE('',#29339,#29688); +#29688 = DEFINITIONAL_REPRESENTATION('',(#29689),#29693); +#29689 = LINE('',#29690,#29691); +#29690 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#29691 = VECTOR('',#29692,1.); +#29692 = DIRECTION('',(-1.,-4.52345554697E-15)); +#29693 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29694 = PCURVE('',#26760,#29695); +#29695 = DEFINITIONAL_REPRESENTATION('',(#29696),#29704); +#29696 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29697,#29698,#29699,#29700 + ,#29701,#29702,#29703),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29697 = CARTESIAN_POINT('',(-31.53553390607,65.135533906111)); +#29698 = CARTESIAN_POINT('',(-25.41180954912,71.259258263069)); +#29699 = CARTESIAN_POINT('',(-23.1703708687,62.894095225691)); +#29700 = CARTESIAN_POINT('',(-20.92893218828,54.528932188313)); +#29701 = CARTESIAN_POINT('',(-29.29409522565,56.770370868733)); +#29702 = CARTESIAN_POINT('',(-37.65925826303,59.011809549153)); +#29703 = CARTESIAN_POINT('',(-31.53553390607,65.135533906111)); +#29704 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29705 = ORIENTED_EDGE('',*,*,#29706,.T.); +#29706 = EDGE_CURVE('',#29679,#29323,#29707,.T.); +#29707 = SURFACE_CURVE('',#29708,(#29712,#29719),.PCURVE_S1.); +#29708 = LINE('',#29709,#29710); +#29709 = CARTESIAN_POINT('',(26.000000000111,-66.60000000026,40.)); +#29710 = VECTOR('',#29711,1.); +#29711 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29712 = PCURVE('',#29339,#29713); +#29713 = DEFINITIONAL_REPRESENTATION('',(#29714),#29718); +#29714 = LINE('',#29715,#29716); +#29715 = CARTESIAN_POINT('',(-0.785398163397,-1.42108547152E-14)); +#29716 = VECTOR('',#29717,1.); +#29717 = DIRECTION('',(-2.537652627715E-16,-1.)); +#29718 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29719 = PCURVE('',#29367,#29720); +#29720 = DEFINITIONAL_REPRESENTATION('',(#29721),#29725); +#29721 = LINE('',#29722,#29723); +#29722 = CARTESIAN_POINT('',(61.000000000189,-6.990823690554E-14)); +#29723 = VECTOR('',#29724,1.); +#29724 = DIRECTION('',(1.227896432782E-16,-1.)); +#29725 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29726 = ORIENTED_EDGE('',*,*,#29322,.T.); +#29727 = ORIENTED_EDGE('',*,*,#29653,.T.); +#29728 = ADVANCED_FACE('',(#29729),#29396,.T.); +#29729 = FACE_BOUND('',#29730,.T.); +#29730 = EDGE_LOOP('',(#29731,#29761,#29782,#29783)); +#29731 = ORIENTED_EDGE('',*,*,#29732,.T.); +#29732 = EDGE_CURVE('',#29733,#29735,#29737,.T.); +#29733 = VERTEX_POINT('',#29734); +#29734 = CARTESIAN_POINT('',(-30.00000000007,-66.60000000026,43.5)); +#29735 = VERTEX_POINT('',#29736); +#29736 = CARTESIAN_POINT('',(-35.00000000007,-61.60000000026,43.5)); +#29737 = SURFACE_CURVE('',#29738,(#29743,#29750),.PCURVE_S1.); +#29738 = CIRCLE('',#29739,5.); +#29739 = AXIS2_PLACEMENT_3D('',#29740,#29741,#29742); +#29740 = CARTESIAN_POINT('',(-30.00000000007,-61.60000000026,43.5)); +#29741 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29742 = DIRECTION('',(-0.707106781187,-0.707106781187, + 3.992707407793E-16)); +#29743 = PCURVE('',#29396,#29744); +#29744 = DEFINITIONAL_REPRESENTATION('',(#29745),#29749); +#29745 = LINE('',#29746,#29747); +#29746 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#29747 = VECTOR('',#29748,1.); +#29748 = DIRECTION('',(-1.,4.52345554697E-15)); +#29749 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29750 = PCURVE('',#26760,#29751); +#29751 = DEFINITIONAL_REPRESENTATION('',(#29752),#29760); +#29752 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29753,#29754,#29755,#29756 + ,#29757,#29758,#29759),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29753 = CARTESIAN_POINT('',(31.535533905976,65.135533906111)); +#29754 = CARTESIAN_POINT('',(37.659258262934,59.011809549153)); +#29755 = CARTESIAN_POINT('',(29.294095225556,56.770370868733)); +#29756 = CARTESIAN_POINT('',(20.928932188178,54.528932188313)); +#29757 = CARTESIAN_POINT('',(23.170370868598,62.894095225691)); +#29758 = CARTESIAN_POINT('',(25.411809549018,71.259258263069)); +#29759 = CARTESIAN_POINT('',(31.535533905976,65.135533906111)); +#29760 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29761 = ORIENTED_EDGE('',*,*,#29762,.T.); +#29762 = EDGE_CURVE('',#29735,#29380,#29763,.T.); +#29763 = SURFACE_CURVE('',#29764,(#29768,#29775),.PCURVE_S1.); +#29764 = LINE('',#29765,#29766); +#29765 = CARTESIAN_POINT('',(-35.00000000007,-61.60000000026,40.)); +#29766 = VECTOR('',#29767,1.); +#29767 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29768 = PCURVE('',#29396,#29769); +#29769 = DEFINITIONAL_REPRESENTATION('',(#29770),#29774); +#29770 = LINE('',#29771,#29772); +#29771 = CARTESIAN_POINT('',(-0.785398163397,7.105427357601E-15)); +#29772 = VECTOR('',#29773,1.); +#29773 = DIRECTION('',(2.537652627715E-16,-1.)); +#29774 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29775 = PCURVE('',#29424,#29776); +#29776 = DEFINITIONAL_REPRESENTATION('',(#29777),#29781); +#29777 = LINE('',#29778,#29779); +#29778 = CARTESIAN_POINT('',(20.000000000224,6.526216766107E-14)); +#29779 = VECTOR('',#29780,1.); +#29780 = DIRECTION('',(8.269618604667E-16,-1.)); +#29781 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29782 = ORIENTED_EDGE('',*,*,#29379,.T.); +#29783 = ORIENTED_EDGE('',*,*,#29784,.T.); +#29784 = EDGE_CURVE('',#29352,#29733,#29785,.T.); +#29785 = SURFACE_CURVE('',#29786,(#29790,#29797),.PCURVE_S1.); +#29786 = LINE('',#29787,#29788); +#29787 = CARTESIAN_POINT('',(-30.00000000007,-66.60000000026,40.)); +#29788 = VECTOR('',#29789,1.); +#29789 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29790 = PCURVE('',#29396,#29791); +#29791 = DEFINITIONAL_REPRESENTATION('',(#29792),#29796); +#29792 = LINE('',#29793,#29794); +#29793 = CARTESIAN_POINT('',(0.785398163397,-1.42108547152E-14)); +#29794 = VECTOR('',#29795,1.); +#29795 = DIRECTION('',(2.854859206179E-16,1.)); +#29796 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29797 = PCURVE('',#29367,#29798); +#29798 = DEFINITIONAL_REPRESENTATION('',(#29799),#29803); +#29799 = LINE('',#29800,#29801); +#29800 = CARTESIAN_POINT('',(5.,-5.730183352895E-15)); +#29801 = VECTOR('',#29802,1.); +#29802 = DIRECTION('',(-1.227896432782E-16,1.)); +#29803 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29804 = ADVANCED_FACE('',(#29805),#29424,.T.); +#29805 = FACE_BOUND('',#29806,.T.); +#29806 = EDGE_LOOP('',(#29807,#29808,#29831,#29852)); +#29807 = ORIENTED_EDGE('',*,*,#29762,.F.); +#29808 = ORIENTED_EDGE('',*,*,#29809,.F.); +#29809 = EDGE_CURVE('',#29810,#29735,#29812,.T.); +#29810 = VERTEX_POINT('',#29811); +#29811 = CARTESIAN_POINT('',(-35.00000000007,-46.1579895577,43.5)); +#29812 = SURFACE_CURVE('',#29813,(#29817,#29824),.PCURVE_S1.); +#29813 = LINE('',#29814,#29815); +#29814 = CARTESIAN_POINT('',(-35.00000000007,-66.60000000026,43.5)); +#29815 = VECTOR('',#29816,1.); +#29816 = DIRECTION('',(-8.881784196922E-17,-1.,1.710690767248E-15)); +#29817 = PCURVE('',#29424,#29818); +#29818 = DEFINITIONAL_REPRESENTATION('',(#29819),#29823); +#29819 = LINE('',#29820,#29821); +#29820 = CARTESIAN_POINT('',(25.000000000224,3.5)); +#29821 = VECTOR('',#29822,1.); +#29822 = DIRECTION('',(1.,0.)); +#29823 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29824 = PCURVE('',#26760,#29825); +#29825 = DEFINITIONAL_REPRESENTATION('',(#29826),#29830); +#29826 = LINE('',#29827,#29828); +#29827 = CARTESIAN_POINT('',(33.000000000043,66.600000000178)); +#29828 = VECTOR('',#29829,1.); +#29829 = DIRECTION('',(8.881784196922E-17,1.)); +#29830 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29831 = ORIENTED_EDGE('',*,*,#29832,.F.); +#29832 = EDGE_CURVE('',#29409,#29810,#29833,.T.); +#29833 = SURFACE_CURVE('',#29834,(#29838,#29845),.PCURVE_S1.); +#29834 = LINE('',#29835,#29836); +#29835 = CARTESIAN_POINT('',(-35.00000000007,-46.1579895577,40.)); +#29836 = VECTOR('',#29837,1.); +#29837 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29838 = PCURVE('',#29424,#29839); +#29839 = DEFINITIONAL_REPRESENTATION('',(#29840),#29844); +#29840 = LINE('',#29841,#29842); +#29841 = CARTESIAN_POINT('',(4.55798955767,9.16786723529E-14)); +#29842 = VECTOR('',#29843,1.); +#29843 = DIRECTION('',(-8.269618604667E-16,1.)); +#29844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29845 = PCURVE('',#29453,#29846); +#29846 = DEFINITIONAL_REPRESENTATION('',(#29847),#29851); +#29847 = LINE('',#29848,#29849); +#29848 = CARTESIAN_POINT('',(6.49653537212,2.13162820728E-14)); +#29849 = VECTOR('',#29850,1.); +#29850 = DIRECTION('',(1.586032892322E-17,1.)); +#29851 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29852 = ORIENTED_EDGE('',*,*,#29408,.F.); +#29853 = ADVANCED_FACE('',(#29854),#29453,.T.); +#29854 = FACE_BOUND('',#29855,.T.); +#29855 = EDGE_LOOP('',(#29856,#29884,#29905,#29906)); +#29856 = ORIENTED_EDGE('',*,*,#29857,.T.); +#29857 = EDGE_CURVE('',#29810,#29858,#29860,.T.); +#29858 = VERTEX_POINT('',#29859); +#29859 = CARTESIAN_POINT('',(-33.20672835524,-37.88060817219,43.5)); +#29860 = SURFACE_CURVE('',#29861,(#29866,#29873),.PCURVE_S1.); +#29861 = CIRCLE('',#29862,20.); +#29862 = AXIS2_PLACEMENT_3D('',#29863,#29864,#29865); +#29863 = CARTESIAN_POINT('',(-15.00000000007,-46.1579895577,43.5)); +#29864 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29865 = DIRECTION('',(-0.977327073645,0.211735191031, + -1.482266101945E-15)); +#29866 = PCURVE('',#29453,#29867); +#29867 = DEFINITIONAL_REPRESENTATION('',(#29868),#29872); +#29868 = LINE('',#29869,#29870); +#29869 = CARTESIAN_POINT('',(12.566370614359,3.5)); +#29870 = VECTOR('',#29871,1.); +#29871 = DIRECTION('',(-1.,1.665203935977E-14)); +#29872 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29873 = PCURVE('',#26760,#29874); +#29874 = DEFINITIONAL_REPRESENTATION('',(#29875),#29883); +#29875 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29876,#29877,#29878,#29879 + ,#29880,#29881,#29882),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29876 = CARTESIAN_POINT('',(32.546541472939,41.923285737008)); +#29877 = CARTESIAN_POINT('',(25.211819300624,8.067682793699)); +#29878 = CARTESIAN_POINT('',(-0.440631822563,31.347539996279)); +#29879 = CARTESIAN_POINT('',(-26.09308294574,54.627397198859)); +#29880 = CARTESIAN_POINT('',(6.894090349752,65.203142939588)); +#29881 = CARTESIAN_POINT('',(39.881263645254,75.778888680316)); +#29882 = CARTESIAN_POINT('',(32.546541472939,41.923285737008)); +#29883 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29884 = ORIENTED_EDGE('',*,*,#29885,.T.); +#29885 = EDGE_CURVE('',#29858,#29437,#29886,.T.); +#29886 = SURFACE_CURVE('',#29887,(#29891,#29898),.PCURVE_S1.); +#29887 = LINE('',#29888,#29889); +#29888 = CARTESIAN_POINT('',(-33.20672835524,-37.88060817219,40.)); +#29889 = VECTOR('',#29890,1.); +#29890 = DIRECTION('',(1.268826313857E-15,-2.537652627715E-15,-1.)); +#29891 = PCURVE('',#29453,#29892); +#29892 = DEFINITIONAL_REPRESENTATION('',(#29893),#29897); +#29893 = LINE('',#29894,#29895); +#29894 = CARTESIAN_POINT('',(6.069835242239,4.263256414561E-14)); +#29895 = VECTOR('',#29896,1.); +#29896 = DIRECTION('',(0.,-1.)); +#29897 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29898 = PCURVE('',#29482,#29899); +#29899 = DEFINITIONAL_REPRESENTATION('',(#29900),#29904); +#29900 = LINE('',#29901,#29902); +#29901 = CARTESIAN_POINT('',(4.511710426264E-02,0.)); +#29902 = VECTOR('',#29903,1.); +#29903 = DIRECTION('',(0.,-1.)); +#29904 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29905 = ORIENTED_EDGE('',*,*,#29436,.T.); +#29906 = ORIENTED_EDGE('',*,*,#29832,.T.); +#29907 = ADVANCED_FACE('',(#29908),#29205,.T.); +#29908 = FACE_BOUND('',#29909,.T.); +#29909 = EDGE_LOOP('',(#29910,#29938,#29939,#29940)); +#29910 = ORIENTED_EDGE('',*,*,#29911,.T.); +#29911 = EDGE_CURVE('',#29912,#29190,#29914,.T.); +#29912 = VERTEX_POINT('',#29913); +#29913 = CARTESIAN_POINT('',(-33.20672835532,37.880608172138,43.5)); +#29914 = SURFACE_CURVE('',#29915,(#29920,#29927),.PCURVE_S1.); +#29915 = CIRCLE('',#29916,20.); +#29916 = AXIS2_PLACEMENT_3D('',#29917,#29918,#29919); +#29917 = CARTESIAN_POINT('',(-15.00000000018,46.157989557691,43.5)); +#29918 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29919 = DIRECTION('',(-0.977327073645,-0.211735191032, + -7.578392291466E-16)); +#29920 = PCURVE('',#29205,#29921); +#29921 = DEFINITIONAL_REPRESENTATION('',(#29922),#29926); +#29922 = LINE('',#29923,#29924); +#29923 = CARTESIAN_POINT('',(12.566370614359,3.5)); +#29924 = VECTOR('',#29925,1.); +#29925 = DIRECTION('',(-1.,1.665203935969E-14)); +#29926 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29927 = PCURVE('',#26760,#29928); +#29928 = DEFINITIONAL_REPRESENTATION('',(#29929),#29937); +#29929 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29930,#29931,#29932,#29933 + ,#29934,#29935,#29936),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29930 = CARTESIAN_POINT('',(32.546541473038,-41.92328573713)); +#29931 = CARTESIAN_POINT('',(39.88126364539,-75.77888868043)); +#29932 = CARTESIAN_POINT('',(6.894090349877,-65.20314293974)); +#29933 = CARTESIAN_POINT('',(-26.09308294563,-54.62739719905)); +#29934 = CARTESIAN_POINT('',(-0.440631822476,-31.34753999644)); +#29935 = CARTESIAN_POINT('',(25.211819300685,-8.067682793834)); +#29936 = CARTESIAN_POINT('',(32.546541473038,-41.92328573713)); +#29937 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29938 = ORIENTED_EDGE('',*,*,#29189,.T.); +#29939 = ORIENTED_EDGE('',*,*,#29494,.T.); +#29940 = ORIENTED_EDGE('',*,*,#29941,.T.); +#29941 = EDGE_CURVE('',#29466,#29912,#29942,.T.); +#29942 = SURFACE_CURVE('',#29943,(#29947,#29954),.PCURVE_S1.); +#29943 = LINE('',#29944,#29945); +#29944 = CARTESIAN_POINT('',(-33.20672835532,37.880608172138,40.)); +#29945 = VECTOR('',#29946,1.); +#29946 = DIRECTION('',(-1.268826313857E-15,2.537652627715E-15,1.)); +#29947 = PCURVE('',#29205,#29948); +#29948 = DEFINITIONAL_REPRESENTATION('',(#29949),#29953); +#29949 = LINE('',#29950,#29951); +#29950 = CARTESIAN_POINT('',(6.496535372121,2.479277130695E-29)); +#29951 = VECTOR('',#29952,1.); +#29952 = DIRECTION('',(0.,1.)); +#29953 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29954 = PCURVE('',#29482,#29955); +#29955 = DEFINITIONAL_REPRESENTATION('',(#29956),#29960); +#29956 = LINE('',#29957,#29958); +#29957 = CARTESIAN_POINT('',(0.898517364027,-7.105427357601E-15)); +#29958 = VECTOR('',#29959,1.); +#29959 = DIRECTION('',(0.,1.)); +#29960 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29961 = ADVANCED_FACE('',(#29962),#29482,.F.); +#29962 = FACE_BOUND('',#29963,.F.); +#29963 = EDGE_LOOP('',(#29964,#29965,#29966,#29992)); +#29964 = ORIENTED_EDGE('',*,*,#29465,.T.); +#29965 = ORIENTED_EDGE('',*,*,#29941,.T.); +#29966 = ORIENTED_EDGE('',*,*,#29967,.T.); +#29967 = EDGE_CURVE('',#29912,#29858,#29968,.T.); +#29968 = SURFACE_CURVE('',#29969,(#29974,#29981),.PCURVE_S1.); +#29969 = CIRCLE('',#29970,91.527999998584); +#29970 = AXIS2_PLACEMENT_3D('',#29971,#29972,#29973); +#29971 = CARTESIAN_POINT('',(-116.5279999985,-1.217656194164E-10,43.5)); +#29972 = DIRECTION('',(1.146036670579E-15,-1.710690767248E-15,-1.)); +#29973 = DIRECTION('',(0.890743816097,-0.45450572503,1.798343824809E-15) + ); +#29974 = PCURVE('',#29482,#29975); +#29975 = DEFINITIONAL_REPRESENTATION('',(#29976),#29980); +#29976 = LINE('',#29977,#29978); +#29977 = CARTESIAN_POINT('',(6.28318530718,3.5)); +#29978 = VECTOR('',#29979,1.); +#29979 = DIRECTION('',(-1.,-6.660815743892E-14)); +#29980 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29981 = PCURVE('',#26760,#29982); +#29982 = DEFINITIONAL_REPRESENTATION('',(#29983),#29991); +#29983 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#29984,#29985,#29986,#29987 + ,#29988,#29989,#29990),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#29984 = CARTESIAN_POINT('',(33.000000000043,41.599999999955)); +#29985 = CARTESIAN_POINT('',(105.05331359476,182.81063823675)); +#29986 = CARTESIAN_POINT('',(191.31865679508,49.805319118481)); +#29987 = CARTESIAN_POINT('',(277.5839999954,-83.19999999979)); +#29988 = CARTESIAN_POINT('',(119.26534320036,-91.40531911831)); +#29989 = CARTESIAN_POINT('',(-39.05331359467,-99.61063823684)); +#29990 = CARTESIAN_POINT('',(33.000000000043,41.599999999955)); +#29991 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#29992 = ORIENTED_EDGE('',*,*,#29885,.T.); +#29993 = ADVANCED_FACE('',(#29994),#29100,.T.); +#29994 = FACE_BOUND('',#29995,.T.); +#29995 = EDGE_LOOP('',(#29996,#29997,#30018,#30019)); +#29996 = ORIENTED_EDGE('',*,*,#29084,.F.); +#29997 = ORIENTED_EDGE('',*,*,#29998,.F.); +#29998 = EDGE_CURVE('',#29554,#29052,#29999,.T.); +#29999 = SURFACE_CURVE('',#30000,(#30004,#30011),.PCURVE_S1.); +#30000 = LINE('',#30001,#30002); +#30001 = CARTESIAN_POINT('',(31.000000000111,66.600000000096,43.5)); +#30002 = VECTOR('',#30003,1.); +#30003 = DIRECTION('',(-1.,1.45092644297E-114,-1.146036670579E-15)); +#30004 = PCURVE('',#29100,#30005); +#30005 = DEFINITIONAL_REPRESENTATION('',(#30006),#30010); +#30006 = LINE('',#30007,#30008); +#30007 = CARTESIAN_POINT('',(-4.011128347027E-15,3.5)); +#30008 = VECTOR('',#30009,1.); +#30009 = DIRECTION('',(1.,0.)); +#30010 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30011 = PCURVE('',#26760,#30012); +#30012 = DEFINITIONAL_REPRESENTATION('',(#30013),#30017); +#30013 = LINE('',#30014,#30015); +#30014 = CARTESIAN_POINT('',(-33.00000000014,-66.60000000017)); +#30015 = VECTOR('',#30016,1.); +#30016 = DIRECTION('',(1.,-1.308603298716E-46)); +#30017 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30018 = ORIENTED_EDGE('',*,*,#29605,.F.); +#30019 = ORIENTED_EDGE('',*,*,#29242,.T.); +#30020 = ADVANCED_FACE('',(#30021),#29367,.T.); +#30021 = FACE_BOUND('',#30022,.T.); +#30022 = EDGE_LOOP('',(#30023,#30024,#30045,#30046)); +#30023 = ORIENTED_EDGE('',*,*,#29706,.F.); +#30024 = ORIENTED_EDGE('',*,*,#30025,.F.); +#30025 = EDGE_CURVE('',#29733,#29679,#30026,.T.); +#30026 = SURFACE_CURVE('',#30027,(#30031,#30038),.PCURVE_S1.); +#30027 = LINE('',#30028,#30029); +#30028 = CARTESIAN_POINT('',(-35.00000000007,-66.60000000026,43.5)); +#30029 = VECTOR('',#30030,1.); +#30030 = DIRECTION('',(1.,-1.45092644297E-114,1.146036670579E-15)); +#30031 = PCURVE('',#29367,#30032); +#30032 = DEFINITIONAL_REPRESENTATION('',(#30033),#30037); +#30033 = LINE('',#30034,#30035); +#30034 = CARTESIAN_POINT('',(4.011128347027E-15,3.5)); +#30035 = VECTOR('',#30036,1.); +#30036 = DIRECTION('',(1.,0.)); +#30037 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30038 = PCURVE('',#26760,#30039); +#30039 = DEFINITIONAL_REPRESENTATION('',(#30040),#30044); +#30040 = LINE('',#30041,#30042); +#30041 = CARTESIAN_POINT('',(33.000000000043,66.600000000178)); +#30042 = VECTOR('',#30043,1.); +#30043 = DIRECTION('',(-1.,1.308603298716E-46)); +#30044 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30045 = ORIENTED_EDGE('',*,*,#29784,.F.); +#30046 = ORIENTED_EDGE('',*,*,#29351,.T.); +#30047 = ADVANCED_FACE('',(#30048,#30062,#30065,#30068,#30074,#30077, + #30080,#30083,#30086,#30089,#30092),#26760,.T.); +#30048 = FACE_BOUND('',#30049,.T.); +#30049 = EDGE_LOOP('',(#30050,#30051,#30052,#30053,#30054,#30055,#30056, + #30057,#30058,#30059,#30060,#30061)); +#30050 = ORIENTED_EDGE('',*,*,#29049,.F.); +#30051 = ORIENTED_EDGE('',*,*,#29217,.T.); +#30052 = ORIENTED_EDGE('',*,*,#29911,.F.); +#30053 = ORIENTED_EDGE('',*,*,#29967,.T.); +#30054 = ORIENTED_EDGE('',*,*,#29857,.F.); +#30055 = ORIENTED_EDGE('',*,*,#29809,.T.); +#30056 = ORIENTED_EDGE('',*,*,#29732,.F.); +#30057 = ORIENTED_EDGE('',*,*,#30025,.T.); +#30058 = ORIENTED_EDGE('',*,*,#29678,.F.); +#30059 = ORIENTED_EDGE('',*,*,#29630,.T.); +#30060 = ORIENTED_EDGE('',*,*,#29553,.F.); +#30061 = ORIENTED_EDGE('',*,*,#29998,.T.); +#30062 = FACE_BOUND('',#30063,.T.); +#30063 = EDGE_LOOP('',(#30064)); +#30064 = ORIENTED_EDGE('',*,*,#27619,.T.); +#30065 = FACE_BOUND('',#30066,.T.); +#30066 = EDGE_LOOP('',(#30067)); +#30067 = ORIENTED_EDGE('',*,*,#27930,.T.); +#30068 = FACE_BOUND('',#30069,.T.); +#30069 = EDGE_LOOP('',(#30070,#30071,#30072,#30073)); +#30070 = ORIENTED_EDGE('',*,*,#28017,.T.); +#30071 = ORIENTED_EDGE('',*,*,#28238,.T.); +#30072 = ORIENTED_EDGE('',*,*,#28169,.T.); +#30073 = ORIENTED_EDGE('',*,*,#28093,.T.); +#30074 = FACE_BOUND('',#30075,.T.); +#30075 = EDGE_LOOP('',(#30076)); +#30076 = ORIENTED_EDGE('',*,*,#28316,.T.); +#30077 = FACE_BOUND('',#30078,.T.); +#30078 = EDGE_LOOP('',(#30079)); +#30079 = ORIENTED_EDGE('',*,*,#28785,.T.); +#30080 = FACE_BOUND('',#30081,.T.); +#30081 = EDGE_LOOP('',(#30082)); +#30082 = ORIENTED_EDGE('',*,*,#28659,.T.); +#30083 = FACE_BOUND('',#30084,.T.); +#30084 = EDGE_LOOP('',(#30085)); +#30085 = ORIENTED_EDGE('',*,*,#28533,.T.); +#30086 = FACE_BOUND('',#30087,.T.); +#30087 = EDGE_LOOP('',(#30088)); +#30088 = ORIENTED_EDGE('',*,*,#28407,.T.); +#30089 = FACE_BOUND('',#30090,.T.); +#30090 = EDGE_LOOP('',(#30091)); +#30091 = ORIENTED_EDGE('',*,*,#27488,.T.); +#30092 = FACE_BOUND('',#30093,.T.); +#30093 = EDGE_LOOP('',(#30094,#30095,#30096,#30097,#30098,#30099,#30100, + #30101)); +#30094 = ORIENTED_EDGE('',*,*,#26831,.T.); +#30095 = ORIENTED_EDGE('',*,*,#26743,.F.); +#30096 = ORIENTED_EDGE('',*,*,#27310,.T.); +#30097 = ORIENTED_EDGE('',*,*,#27239,.F.); +#30098 = ORIENTED_EDGE('',*,*,#27139,.T.); +#30099 = ORIENTED_EDGE('',*,*,#27090,.F.); +#30100 = ORIENTED_EDGE('',*,*,#26985,.T.); +#30101 = ORIENTED_EDGE('',*,*,#26936,.F.); +#30102 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#30106)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#30103,#30104,#30105)) +REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#30103 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#30104 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#30105 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#30106 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#30103, + 'distance_accuracy_value','confusion accuracy'); +#30107 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#30108,#30110); +#30108 = ( REPRESENTATION_RELATIONSHIP('','',#26701,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#30109) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#30109 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#30110 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item', + #30111); +#30111 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('4','DeskTop','',#5,#26696,$); +#30112 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#26698)); +#30113 = SHAPE_DEFINITION_REPRESENTATION(#30114,#30120); +#30114 = PRODUCT_DEFINITION_SHAPE('','',#30115); +#30115 = PRODUCT_DEFINITION('design','',#30116,#30119); +#30116 = PRODUCT_DEFINITION_FORMATION('','',#30117); +#30117 = PRODUCT('DeskPad','DeskPad','',(#30118)); +#30118 = PRODUCT_CONTEXT('',#2,'mechanical'); +#30119 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#30120 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#30121),#35155); +#30121 = MANIFOLD_SOLID_BREP('',#30122); +#30122 = CLOSED_SHELL('',(#30123,#30277,#30358,#30557,#30706,#30905, + #30954,#32201,#32271,#32298,#32407,#32591,#32618,#32688,#32715, + #32785,#32812,#32921,#32970,#33074,#33123,#33172,#33243,#33292, + #33341,#33368,#33444,#33521,#33568,#33618,#33645,#33656,#33705, + #33755,#33782,#33789,#33838,#33888,#33915,#33942,#33949,#33998, + #34048,#34075,#34082,#34153,#34202,#34251,#34278,#34332,#34386, + #34440,#34494,#34548,#34597,#34624,#34673,#34700,#34749,#34798, + #34825,#34874,#34923,#34972,#35021,#35070,#35097)); +#30123 = ADVANCED_FACE('',(#30124),#30139,.T.); +#30124 = FACE_BOUND('',#30125,.T.); +#30125 = EDGE_LOOP('',(#30126,#30166,#30194,#30222,#30251)); +#30126 = ORIENTED_EDGE('',*,*,#30127,.T.); +#30127 = EDGE_CURVE('',#30128,#30130,#30132,.T.); +#30128 = VERTEX_POINT('',#30129); +#30129 = CARTESIAN_POINT('',(32.800000000164,60.100008269699,43.5)); +#30130 = VERTEX_POINT('',#30131); +#30131 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,43.5)); +#30132 = SURFACE_CURVE('',#30133,(#30138,#30150),.PCURVE_S1.); +#30133 = CIRCLE('',#30134,1.5); +#30134 = AXIS2_PLACEMENT_3D('',#30135,#30136,#30137); +#30135 = CARTESIAN_POINT('',(31.300000000164,60.100008269699,43.5)); +#30136 = DIRECTION('',(-1.42106068382E-27,-1.980689724944E-15,-1.)); +#30137 = DIRECTION('',(0.707106781187,-0.707106781187,1.400559135934E-15 + )); +#30138 = PCURVE('',#30139,#30144); +#30139 = CYLINDRICAL_SURFACE('',#30140,1.5); +#30140 = AXIS2_PLACEMENT_3D('',#30141,#30142,#30143); +#30141 = CARTESIAN_POINT('',(31.300000000164,60.100008269699,38.5)); +#30142 = DIRECTION('',(4.48415508584E-44,-7.171696191935E-87,1.)); +#30143 = DIRECTION('',(0.707106781187,-0.707106781187,-3.17077646909E-44 + )); +#30144 = DEFINITIONAL_REPRESENTATION('',(#30145),#30149); +#30145 = LINE('',#30146,#30147); +#30146 = CARTESIAN_POINT('',(6.28318530718,5.)); +#30147 = VECTOR('',#30148,1.); +#30148 = DIRECTION('',(-1.,0.)); +#30149 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30150 = PCURVE('',#30151,#30156); +#30151 = PLANE('',#30152); +#30152 = AXIS2_PLACEMENT_3D('',#30153,#30154,#30155); +#30153 = CARTESIAN_POINT('',(27.900000000175,63.500008269877,43.5)); +#30154 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30155 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30156 = DEFINITIONAL_REPRESENTATION('',(#30157),#30165); +#30157 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30158,#30159,#30160,#30161 + ,#30162,#30163,#30164),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30158 = CARTESIAN_POINT('',(-4.460660171769,4.460660171958)); +#30159 = CARTESIAN_POINT('',(-2.623542864681,6.297777479045)); +#30160 = CARTESIAN_POINT('',(-1.951111260555,3.788228567832)); +#30161 = CARTESIAN_POINT('',(-1.278679656429,1.278679656618)); +#30162 = CARTESIAN_POINT('',(-3.788228567643,1.951111260744)); +#30163 = CARTESIAN_POINT('',(-6.297777478856,2.62354286487)); +#30164 = CARTESIAN_POINT('',(-4.460660171769,4.460660171958)); +#30165 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30166 = ORIENTED_EDGE('',*,*,#30167,.F.); +#30167 = EDGE_CURVE('',#30168,#30130,#30170,.T.); +#30168 = VERTEX_POINT('',#30169); +#30169 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,40.)); +#30170 = SURFACE_CURVE('',#30171,(#30175,#30182),.PCURVE_S1.); +#30171 = LINE('',#30172,#30173); +#30172 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,38.5)); +#30173 = VECTOR('',#30174,1.); +#30174 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30175 = PCURVE('',#30139,#30176); +#30176 = DEFINITIONAL_REPRESENTATION('',(#30177),#30181); +#30177 = LINE('',#30178,#30179); +#30178 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#30179 = VECTOR('',#30180,1.); +#30180 = DIRECTION('',(-1.015061051086E-15,1.)); +#30181 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30182 = PCURVE('',#30183,#30188); +#30183 = PLANE('',#30184); +#30184 = AXIS2_PLACEMENT_3D('',#30185,#30186,#30187); +#30185 = CARTESIAN_POINT('',(31.300000000164,61.600008269707,38.5)); +#30186 = DIRECTION('',(-1.,-2.81449061189E-42,4.48415508584E-44)); +#30187 = DIRECTION('',(2.81449061189E-42,-1.,1.980689724944E-15)); +#30188 = DEFINITIONAL_REPRESENTATION('',(#30189),#30193); +#30189 = LINE('',#30190,#30191); +#30190 = CARTESIAN_POINT('',(3.000000000007,-5.942069174847E-15)); +#30191 = VECTOR('',#30192,1.); +#30192 = DIRECTION('',(2.043328855439E-16,1.)); +#30193 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30194 = ORIENTED_EDGE('',*,*,#30195,.T.); +#30195 = EDGE_CURVE('',#30168,#30196,#30198,.T.); +#30196 = VERTEX_POINT('',#30197); +#30197 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,38.5)); +#30198 = SURFACE_CURVE('',#30199,(#30203,#30210),.PCURVE_S1.); +#30199 = LINE('',#30200,#30201); +#30200 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,38.5)); +#30201 = VECTOR('',#30202,1.); +#30202 = DIRECTION('',(-4.48415508584E-44,7.171696191935E-87,-1.)); +#30203 = PCURVE('',#30139,#30204); +#30204 = DEFINITIONAL_REPRESENTATION('',(#30205),#30209); +#30205 = LINE('',#30206,#30207); +#30206 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#30207 = VECTOR('',#30208,1.); +#30208 = DIRECTION('',(0.,-1.)); +#30209 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30210 = PCURVE('',#30211,#30216); +#30211 = PLANE('',#30212); +#30212 = AXIS2_PLACEMENT_3D('',#30213,#30214,#30215); +#30213 = CARTESIAN_POINT('',(31.000000000132,58.600008269699,38.5)); +#30214 = DIRECTION('',(5.205416047476E-145,-1.,-7.171696191935E-87)); +#30215 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#30216 = DEFINITIONAL_REPRESENTATION('',(#30217),#30221); +#30217 = LINE('',#30218,#30219); +#30218 = CARTESIAN_POINT('',(0.300000000032,4.26289475339E-28)); +#30219 = VECTOR('',#30220,1.); +#30220 = DIRECTION('',(1.420964917647E-27,-1.)); +#30221 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30222 = ORIENTED_EDGE('',*,*,#30223,.T.); +#30223 = EDGE_CURVE('',#30196,#30224,#30226,.T.); +#30224 = VERTEX_POINT('',#30225); +#30225 = CARTESIAN_POINT('',(32.800000000164,60.100008269699,38.5)); +#30226 = SURFACE_CURVE('',#30227,(#30232,#30239),.PCURVE_S1.); +#30227 = CIRCLE('',#30228,1.5); +#30228 = AXIS2_PLACEMENT_3D('',#30229,#30230,#30231); +#30229 = CARTESIAN_POINT('',(31.300000000164,60.100008269699,38.5)); +#30230 = DIRECTION('',(1.42106068382E-27,1.980689724944E-15,1.)); +#30231 = DIRECTION('',(0.707106781187,-0.707106781187,1.400559135934E-15 + )); +#30232 = PCURVE('',#30139,#30233); +#30233 = DEFINITIONAL_REPRESENTATION('',(#30234),#30238); +#30234 = LINE('',#30235,#30236); +#30235 = CARTESIAN_POINT('',(-6.28318530718,1.06581410364E-13)); +#30236 = VECTOR('',#30237,1.); +#30237 = DIRECTION('',(1.,0.)); +#30238 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30239 = PCURVE('',#30240,#30245); +#30240 = PLANE('',#30241); +#30241 = AXIS2_PLACEMENT_3D('',#30242,#30243,#30244); +#30242 = CARTESIAN_POINT('',(-1.999999999999,8.269953332627E-06,38.5)); +#30243 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30244 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30245 = DEFINITIONAL_REPRESENTATION('',(#30246),#30250); +#30246 = CIRCLE('',#30247,1.5); +#30247 = AXIS2_PLACEMENT_2D('',#30248,#30249); +#30248 = CARTESIAN_POINT('',(-33.30000000016,-60.09999999974)); +#30249 = DIRECTION('',(-0.707106781187,0.707106781187)); +#30250 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30251 = ORIENTED_EDGE('',*,*,#30252,.T.); +#30252 = EDGE_CURVE('',#30224,#30128,#30253,.T.); +#30253 = SURFACE_CURVE('',#30254,(#30258,#30265),.PCURVE_S1.); +#30254 = LINE('',#30255,#30256); +#30255 = CARTESIAN_POINT('',(32.800000000164,60.100008269699,38.5)); +#30256 = VECTOR('',#30257,1.); +#30257 = DIRECTION('',(4.48415508584E-44,-7.171696191935E-87,1.)); +#30258 = PCURVE('',#30139,#30259); +#30259 = DEFINITIONAL_REPRESENTATION('',(#30260),#30264); +#30260 = LINE('',#30261,#30262); +#30261 = CARTESIAN_POINT('',(0.785398163397,0.)); +#30262 = VECTOR('',#30263,1.); +#30263 = DIRECTION('',(0.,1.)); +#30264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30265 = PCURVE('',#30266,#30271); +#30266 = PLANE('',#30267); +#30267 = AXIS2_PLACEMENT_3D('',#30268,#30269,#30270); +#30268 = CARTESIAN_POINT('',(32.800000000164,58.600008269699,38.5)); +#30269 = DIRECTION('',(1.,2.81449061189E-42,-4.48415508584E-44)); +#30270 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#30271 = DEFINITIONAL_REPRESENTATION('',(#30272),#30276); +#30272 = LINE('',#30273,#30274); +#30273 = CARTESIAN_POINT('',(1.5,2.971034587416E-15)); +#30274 = VECTOR('',#30275,1.); +#30275 = DIRECTION('',(-1.980689724944E-15,1.)); +#30276 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30277 = ADVANCED_FACE('',(#30278),#30211,.T.); +#30278 = FACE_BOUND('',#30279,.T.); +#30279 = EDGE_LOOP('',(#30280,#30281,#30309,#30337)); +#30280 = ORIENTED_EDGE('',*,*,#30195,.F.); +#30281 = ORIENTED_EDGE('',*,*,#30282,.F.); +#30282 = EDGE_CURVE('',#30283,#30168,#30285,.T.); +#30283 = VERTEX_POINT('',#30284); +#30284 = CARTESIAN_POINT('',(31.000000000132,58.600008269699,40.)); +#30285 = SURFACE_CURVE('',#30286,(#30290,#30297),.PCURVE_S1.); +#30286 = LINE('',#30287,#30288); +#30287 = CARTESIAN_POINT('',(31.000000000116,58.600008269699,40.)); +#30288 = VECTOR('',#30289,1.); +#30289 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#30290 = PCURVE('',#30211,#30291); +#30291 = DEFINITIONAL_REPRESENTATION('',(#30292),#30296); +#30292 = LINE('',#30293,#30294); +#30293 = CARTESIAN_POINT('',(-1.620037437533E-11,1.5)); +#30294 = VECTOR('',#30295,1.); +#30295 = DIRECTION('',(1.,0.)); +#30296 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30297 = PCURVE('',#30298,#30303); +#30298 = PLANE('',#30299); +#30299 = AXIS2_PLACEMENT_3D('',#30300,#30301,#30302); +#30300 = CARTESIAN_POINT('',(-1.999999999999,8.269953332627E-06,40.)); +#30301 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30302 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30303 = DEFINITIONAL_REPRESENTATION('',(#30304),#30308); +#30304 = LINE('',#30305,#30306); +#30305 = CARTESIAN_POINT('',(-33.00000000011,-58.59999999974)); +#30306 = VECTOR('',#30307,1.); +#30307 = DIRECTION('',(-1.,-8.723744686338E-59)); +#30308 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30309 = ORIENTED_EDGE('',*,*,#30310,.F.); +#30310 = EDGE_CURVE('',#30311,#30283,#30313,.T.); +#30311 = VERTEX_POINT('',#30312); +#30312 = CARTESIAN_POINT('',(31.000000000132,58.600008269699,38.5)); +#30313 = SURFACE_CURVE('',#30314,(#30318,#30325),.PCURVE_S1.); +#30314 = LINE('',#30315,#30316); +#30315 = CARTESIAN_POINT('',(31.000000000132,58.600008269699,38.5)); +#30316 = VECTOR('',#30317,1.); +#30317 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#30318 = PCURVE('',#30211,#30319); +#30319 = DEFINITIONAL_REPRESENTATION('',(#30320),#30324); +#30320 = LINE('',#30321,#30322); +#30321 = CARTESIAN_POINT('',(0.,0.)); +#30322 = VECTOR('',#30323,1.); +#30323 = DIRECTION('',(-1.420964917647E-27,1.)); +#30324 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30325 = PCURVE('',#30326,#30331); +#30326 = PLANE('',#30327); +#30327 = AXIS2_PLACEMENT_3D('',#30328,#30329,#30330); +#30328 = CARTESIAN_POINT('',(31.000000000244,-58.59999173036,38.5)); +#30329 = DIRECTION('',(1.,9.503220721166E-13,-4.484155085839E-44)); +#30330 = DIRECTION('',(-9.503220721166E-13,1.,-1.980689724944E-15)); +#30331 = DEFINITIONAL_REPRESENTATION('',(#30332),#30336); +#30332 = LINE('',#30333,#30334); +#30333 = CARTESIAN_POINT('',(117.20000000006,-7.339654061326E-14)); +#30334 = VECTOR('',#30335,1.); +#30335 = DIRECTION('',(-1.980689724944E-15,1.)); +#30336 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30337 = ORIENTED_EDGE('',*,*,#30338,.T.); +#30338 = EDGE_CURVE('',#30311,#30196,#30339,.T.); +#30339 = SURFACE_CURVE('',#30340,(#30344,#30351),.PCURVE_S1.); +#30340 = LINE('',#30341,#30342); +#30341 = CARTESIAN_POINT('',(31.000000000116,58.600008269699,38.5)); +#30342 = VECTOR('',#30343,1.); +#30343 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#30344 = PCURVE('',#30211,#30345); +#30345 = DEFINITIONAL_REPRESENTATION('',(#30346),#30350); +#30346 = LINE('',#30347,#30348); +#30347 = CARTESIAN_POINT('',(-1.620037437533E-11,-2.302016364009E-38)); +#30348 = VECTOR('',#30349,1.); +#30349 = DIRECTION('',(1.,0.)); +#30350 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30351 = PCURVE('',#30240,#30352); +#30352 = DEFINITIONAL_REPRESENTATION('',(#30353),#30357); +#30353 = LINE('',#30354,#30355); +#30354 = CARTESIAN_POINT('',(-33.00000000011,-58.59999999974)); +#30355 = VECTOR('',#30356,1.); +#30356 = DIRECTION('',(-1.,-8.723744686338E-59)); +#30357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30358 = ADVANCED_FACE('',(#30359),#30151,.T.); +#30359 = FACE_BOUND('',#30360,.T.); +#30360 = EDGE_LOOP('',(#30361,#30362,#30385,#30414,#30442,#30475,#30503, + #30536)); +#30361 = ORIENTED_EDGE('',*,*,#30127,.F.); +#30362 = ORIENTED_EDGE('',*,*,#30363,.T.); +#30363 = EDGE_CURVE('',#30128,#30364,#30366,.T.); +#30364 = VERTEX_POINT('',#30365); +#30365 = CARTESIAN_POINT('',(32.800000000164,61.600008269707,43.5)); +#30366 = SURFACE_CURVE('',#30367,(#30371,#30378),.PCURVE_S1.); +#30367 = LINE('',#30368,#30369); +#30368 = CARTESIAN_POINT('',(32.800000000164,58.600008269699,43.5)); +#30369 = VECTOR('',#30370,1.); +#30370 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#30371 = PCURVE('',#30151,#30372); +#30372 = DEFINITIONAL_REPRESENTATION('',(#30373),#30377); +#30373 = LINE('',#30374,#30375); +#30374 = CARTESIAN_POINT('',(-4.899999999989,4.900000000178)); +#30375 = VECTOR('',#30376,1.); +#30376 = DIRECTION('',(-4.866513180261E-57,-1.)); +#30377 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30378 = PCURVE('',#30266,#30379); +#30379 = DEFINITIONAL_REPRESENTATION('',(#30380),#30384); +#30380 = LINE('',#30381,#30382); +#30381 = CARTESIAN_POINT('',(-9.903448624721E-15,5.)); +#30382 = VECTOR('',#30383,1.); +#30383 = DIRECTION('',(1.,0.)); +#30384 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30385 = ORIENTED_EDGE('',*,*,#30386,.T.); +#30386 = EDGE_CURVE('',#30364,#30387,#30389,.T.); +#30387 = VERTEX_POINT('',#30388); +#30388 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,43.5)); +#30389 = SURFACE_CURVE('',#30390,(#30395,#30402),.PCURVE_S1.); +#30390 = CIRCLE('',#30391,6.800000000012); +#30391 = AXIS2_PLACEMENT_3D('',#30392,#30393,#30394); +#30392 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,43.5)); +#30393 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30394 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#30395 = PCURVE('',#30151,#30396); +#30396 = DEFINITIONAL_REPRESENTATION('',(#30397),#30401); +#30397 = CIRCLE('',#30398,6.800000000012); +#30398 = AXIS2_PLACEMENT_2D('',#30399,#30400); +#30399 = CARTESIAN_POINT('',(1.900000000023,1.900000000171)); +#30400 = DIRECTION('',(-1.,-8.723744686338E-59)); +#30401 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30402 = PCURVE('',#30403,#30408); +#30403 = CYLINDRICAL_SURFACE('',#30404,6.800000000012); +#30404 = AXIS2_PLACEMENT_3D('',#30405,#30406,#30407); +#30405 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,38.5)); +#30406 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30407 = DIRECTION('',(1.,2.52414075001E-42,-4.48415508584E-44)); +#30408 = DEFINITIONAL_REPRESENTATION('',(#30409),#30413); +#30409 = LINE('',#30410,#30411); +#30410 = CARTESIAN_POINT('',(0.,5.)); +#30411 = VECTOR('',#30412,1.); +#30412 = DIRECTION('',(1.,0.)); +#30413 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30414 = ORIENTED_EDGE('',*,*,#30415,.T.); +#30415 = EDGE_CURVE('',#30387,#30416,#30418,.T.); +#30416 = VERTEX_POINT('',#30417); +#30417 = CARTESIAN_POINT('',(24.500000000311,68.400008269824,43.5)); +#30418 = SURFACE_CURVE('',#30419,(#30423,#30430),.PCURVE_S1.); +#30419 = LINE('',#30420,#30421); +#30420 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,43.5)); +#30421 = VECTOR('',#30422,1.); +#30422 = DIRECTION('',(-1.,8.318041361553E-11,-1.633336256472E-25)); +#30423 = PCURVE('',#30151,#30424); +#30424 = DEFINITIONAL_REPRESENTATION('',(#30425),#30429); +#30425 = LINE('',#30426,#30427); +#30426 = CARTESIAN_POINT('',(1.899983554382,-4.899999999822)); +#30427 = VECTOR('',#30428,1.); +#30428 = DIRECTION('',(1.,-8.318041361553E-11)); +#30429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30430 = PCURVE('',#30431,#30436); +#30431 = PLANE('',#30432); +#30432 = AXIS2_PLACEMENT_3D('',#30433,#30434,#30435); +#30433 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,38.5)); +#30434 = DIRECTION('',(8.318041361553E-11,1.,-1.7763568394E-15)); +#30435 = DIRECTION('',(-1.,8.318041361553E-11,-1.633336256472E-25)); +#30436 = DEFINITIONAL_REPRESENTATION('',(#30437),#30441); +#30437 = LINE('',#30438,#30439); +#30438 = CARTESIAN_POINT('',(3.653966448045E-25,5.)); +#30439 = VECTOR('',#30440,1.); +#30440 = DIRECTION('',(1.,0.)); +#30441 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30442 = ORIENTED_EDGE('',*,*,#30443,.F.); +#30443 = EDGE_CURVE('',#30444,#30416,#30446,.T.); +#30444 = VERTEX_POINT('',#30445); +#30445 = CARTESIAN_POINT('',(23.000000000186,66.900008269948,43.5)); +#30446 = SURFACE_CURVE('',#30447,(#30452,#30463),.PCURVE_S1.); +#30447 = CIRCLE('',#30448,1.5); +#30448 = AXIS2_PLACEMENT_3D('',#30449,#30450,#30451); +#30449 = CARTESIAN_POINT('',(24.500000000186,66.900008269824,43.5)); +#30450 = DIRECTION('',(-1.420980985805E-27,-1.980689724944E-15,-1.)); +#30451 = DIRECTION('',(-0.707106781157,0.707106781216, + -1.400559135992E-15)); +#30452 = PCURVE('',#30151,#30453); +#30453 = DEFINITIONAL_REPRESENTATION('',(#30454),#30462); +#30454 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30455,#30456,#30457,#30458 + ,#30459,#30460,#30461),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30455 = CARTESIAN_POINT('',(4.460660171725,-4.46066017177)); +#30456 = CARTESIAN_POINT('',(2.623542864561,-6.297777478781)); +#30457 = CARTESIAN_POINT('',(1.951111260539,-3.78822856754)); +#30458 = CARTESIAN_POINT('',(1.278679656517,-1.278679656298)); +#30459 = CARTESIAN_POINT('',(3.788228567703,-1.951111260529)); +#30460 = CARTESIAN_POINT('',(6.297777478888,-2.623542864759)); +#30461 = CARTESIAN_POINT('',(4.460660171725,-4.46066017177)); +#30462 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30463 = PCURVE('',#30464,#30469); +#30464 = CYLINDRICAL_SURFACE('',#30465,1.5); +#30465 = AXIS2_PLACEMENT_3D('',#30466,#30467,#30468); +#30466 = CARTESIAN_POINT('',(24.500000000186,66.900008269824,38.5)); +#30467 = DIRECTION('',(-5.259072698692E-29,1.7763568394E-15,1.)); +#30468 = DIRECTION('',(-0.707106781157,0.707106781216, + -1.256073966999E-15)); +#30469 = DEFINITIONAL_REPRESENTATION('',(#30470),#30474); +#30470 = LINE('',#30471,#30472); +#30471 = CARTESIAN_POINT('',(6.28318530718,5.)); +#30472 = VECTOR('',#30473,1.); +#30473 = DIRECTION('',(-1.,0.)); +#30474 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30475 = ORIENTED_EDGE('',*,*,#30476,.T.); +#30476 = EDGE_CURVE('',#30444,#30477,#30479,.T.); +#30477 = VERTEX_POINT('',#30478); +#30478 = CARTESIAN_POINT('',(26.000012818078,66.900008269949,43.5)); +#30479 = SURFACE_CURVE('',#30480,(#30484,#30491),.PCURVE_S1.); +#30480 = LINE('',#30481,#30482); +#30481 = CARTESIAN_POINT('',(26.000012818078,66.900008269949,43.5)); +#30482 = VECTOR('',#30483,1.); +#30483 = DIRECTION('',(1.,4.736931332577E-14,-1.514788829829E-27)); +#30484 = PCURVE('',#30151,#30485); +#30485 = DEFINITIONAL_REPRESENTATION('',(#30486),#30490); +#30486 = LINE('',#30487,#30488); +#30487 = CARTESIAN_POINT('',(1.899987182097,-3.400000000071)); +#30488 = VECTOR('',#30489,1.); +#30489 = DIRECTION('',(-1.,-4.736931332577E-14)); +#30490 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30491 = PCURVE('',#30492,#30497); +#30492 = PLANE('',#30493); +#30493 = AXIS2_PLACEMENT_3D('',#30494,#30495,#30496); +#30494 = CARTESIAN_POINT('',(23.000000000186,66.900008269948,38.5)); +#30495 = DIRECTION('',(4.736931332577E-14,-1.,1.7763568394E-15)); +#30496 = DIRECTION('',(1.,4.736931332577E-14,-1.514788829829E-27)); +#30497 = DEFINITIONAL_REPRESENTATION('',(#30498),#30502); +#30498 = LINE('',#30499,#30500); +#30499 = CARTESIAN_POINT('',(3.000012817892,5.)); +#30500 = VECTOR('',#30501,1.); +#30501 = DIRECTION('',(1.,0.)); +#30502 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30503 = ORIENTED_EDGE('',*,*,#30504,.T.); +#30504 = EDGE_CURVE('',#30477,#30505,#30507,.T.); +#30505 = VERTEX_POINT('',#30506); +#30506 = CARTESIAN_POINT('',(31.300000000164,61.600008269707,43.5)); +#30507 = SURFACE_CURVE('',#30508,(#30513,#30524),.PCURVE_S1.); +#30508 = CIRCLE('',#30509,5.300000000012); +#30509 = AXIS2_PLACEMENT_3D('',#30510,#30511,#30512); +#30510 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,43.5)); +#30511 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#30512 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#30513 = PCURVE('',#30151,#30514); +#30514 = DEFINITIONAL_REPRESENTATION('',(#30515),#30523); +#30515 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30516,#30517,#30518,#30519 + ,#30520,#30521,#30522),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30516 = CARTESIAN_POINT('',(-3.399999999989,1.900000000171)); +#30517 = CARTESIAN_POINT('',(-3.399999999989,11.079869280307)); +#30518 = CARTESIAN_POINT('',(4.550000000029,6.489934640239)); +#30519 = CARTESIAN_POINT('',(12.500000000047,1.900000000171)); +#30520 = CARTESIAN_POINT('',(4.550000000029,-2.689934639897)); +#30521 = CARTESIAN_POINT('',(-3.399999999989,-7.279869279965)); +#30522 = CARTESIAN_POINT('',(-3.399999999989,1.900000000171)); +#30523 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30524 = PCURVE('',#30525,#30530); +#30525 = CYLINDRICAL_SURFACE('',#30526,5.300000000012); +#30526 = AXIS2_PLACEMENT_3D('',#30527,#30528,#30529); +#30527 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,38.5)); +#30528 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30529 = DIRECTION('',(1.,2.52414075001E-42,-4.48415508584E-44)); +#30530 = DEFINITIONAL_REPRESENTATION('',(#30531),#30535); +#30531 = LINE('',#30532,#30533); +#30532 = CARTESIAN_POINT('',(6.28318530718,5.)); +#30533 = VECTOR('',#30534,1.); +#30534 = DIRECTION('',(-1.,-4.52346251152E-15)); +#30535 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30536 = ORIENTED_EDGE('',*,*,#30537,.T.); +#30537 = EDGE_CURVE('',#30505,#30130,#30538,.T.); +#30538 = SURFACE_CURVE('',#30539,(#30543,#30550),.PCURVE_S1.); +#30539 = LINE('',#30540,#30541); +#30540 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,43.5)); +#30541 = VECTOR('',#30542,1.); +#30542 = DIRECTION('',(2.81449061189E-42,-1.,1.980689724944E-15)); +#30543 = PCURVE('',#30151,#30544); +#30544 = DEFINITIONAL_REPRESENTATION('',(#30545),#30549); +#30545 = LINE('',#30546,#30547); +#30546 = CARTESIAN_POINT('',(-3.399999999989,4.900000000178)); +#30547 = VECTOR('',#30548,1.); +#30548 = DIRECTION('',(4.866513180261E-57,1.)); +#30549 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30550 = PCURVE('',#30183,#30551); +#30551 = DEFINITIONAL_REPRESENTATION('',(#30552),#30556); +#30552 = LINE('',#30553,#30554); +#30553 = CARTESIAN_POINT('',(3.000000000007,5.)); +#30554 = VECTOR('',#30555,1.); +#30555 = DIRECTION('',(1.,0.)); +#30556 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30557 = ADVANCED_FACE('',(#30558),#30573,.T.); +#30558 = FACE_BOUND('',#30559,.T.); +#30559 = EDGE_LOOP('',(#30560,#30600,#30628,#30656,#30680)); +#30560 = ORIENTED_EDGE('',*,*,#30561,.T.); +#30561 = EDGE_CURVE('',#30562,#30564,#30566,.T.); +#30562 = VERTEX_POINT('',#30563); +#30563 = CARTESIAN_POINT('',(-36.7999999998,-60.09999173027,43.5)); +#30564 = VERTEX_POINT('',#30565); +#30565 = CARTESIAN_POINT('',(-35.29999999975,-58.59999173031,43.5)); +#30566 = SURFACE_CURVE('',#30567,(#30572,#30584),.PCURVE_S1.); +#30567 = CIRCLE('',#30568,1.5); +#30568 = AXIS2_PLACEMENT_3D('',#30569,#30570,#30571); +#30569 = CARTESIAN_POINT('',(-35.2999999998,-60.09999173031,43.5)); +#30570 = DIRECTION('',(-1.420901018281E-27,-1.980689724944E-15,-1.)); +#30571 = DIRECTION('',(-0.707106781177,0.707106781196, + -1.400559135953E-15)); +#30572 = PCURVE('',#30573,#30578); +#30573 = CYLINDRICAL_SURFACE('',#30574,1.5); +#30574 = AXIS2_PLACEMENT_3D('',#30575,#30576,#30577); +#30575 = CARTESIAN_POINT('',(-35.2999999998,-60.09999173031,38.5)); +#30576 = DIRECTION('',(-4.831970259692E-26,8.583303420669E-39,1.)); +#30577 = DIRECTION('',(-0.707106781177,0.707106781196, + -3.416718937074E-26)); +#30578 = DEFINITIONAL_REPRESENTATION('',(#30579),#30583); +#30579 = LINE('',#30580,#30581); +#30580 = CARTESIAN_POINT('',(12.566370614359,5.)); +#30581 = VECTOR('',#30582,1.); +#30582 = DIRECTION('',(-1.,0.)); +#30583 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30584 = PCURVE('',#30585,#30590); +#30585 = PLANE('',#30586); +#30586 = AXIS2_PLACEMENT_3D('',#30587,#30588,#30589); +#30587 = CARTESIAN_POINT('',(-31.89999999987,-63.49999173022,43.5)); +#30588 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30589 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30590 = DEFINITIONAL_REPRESENTATION('',(#30591),#30599); +#30591 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30592,#30593,#30594,#30595 + ,#30596,#30597,#30598),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30592 = CARTESIAN_POINT('',(4.460660171687,-4.460660171703)); +#30593 = CARTESIAN_POINT('',(2.623542864574,-6.297777478766)); +#30594 = CARTESIAN_POINT('',(1.951111260482,-3.788228567543)); +#30595 = CARTESIAN_POINT('',(1.278679656391,-1.27867965632)); +#30596 = CARTESIAN_POINT('',(3.788228567595,-1.951111260481)); +#30597 = CARTESIAN_POINT('',(6.297777478799,-2.623542864641)); +#30598 = CARTESIAN_POINT('',(4.460660171687,-4.460660171703)); +#30599 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30600 = ORIENTED_EDGE('',*,*,#30601,.F.); +#30601 = EDGE_CURVE('',#30602,#30564,#30604,.T.); +#30602 = VERTEX_POINT('',#30603); +#30603 = CARTESIAN_POINT('',(-35.29999999975,-58.59999173031,40.)); +#30604 = SURFACE_CURVE('',#30605,(#30609,#30616),.PCURVE_S1.); +#30605 = LINE('',#30606,#30607); +#30606 = CARTESIAN_POINT('',(-35.29999999975,-58.59999173031,38.5)); +#30607 = VECTOR('',#30608,1.); +#30608 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30609 = PCURVE('',#30573,#30610); +#30610 = DEFINITIONAL_REPRESENTATION('',(#30611),#30615); +#30611 = LINE('',#30612,#30613); +#30612 = CARTESIAN_POINT('',(5.497787143769,0.)); +#30613 = VECTOR('',#30614,1.); +#30614 = DIRECTION('',(0.,1.)); +#30615 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30616 = PCURVE('',#30617,#30622); +#30617 = PLANE('',#30618); +#30618 = AXIS2_PLACEMENT_3D('',#30619,#30620,#30621); +#30619 = CARTESIAN_POINT('',(-35.29999999984,-61.59999173032,38.5)); +#30620 = DIRECTION('',(1.,-2.72026845493E-11,4.832167474919E-26)); +#30621 = DIRECTION('',(2.72026845493E-11,1.,-1.980689724944E-15)); +#30622 = DEFINITIONAL_REPRESENTATION('',(#30623),#30627); +#30623 = LINE('',#30624,#30625); +#30624 = CARTESIAN_POINT('',(3.000000000008,5.942069174848E-15)); +#30625 = VECTOR('',#30626,1.); +#30626 = DIRECTION('',(-2.043328855439E-16,1.)); +#30627 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30628 = ORIENTED_EDGE('',*,*,#30629,.T.); +#30629 = EDGE_CURVE('',#30602,#30630,#30632,.T.); +#30630 = VERTEX_POINT('',#30631); +#30631 = CARTESIAN_POINT('',(-35.29999999979,-58.59999173031,38.5)); +#30632 = SURFACE_CURVE('',#30633,(#30637,#30644),.PCURVE_S1.); +#30633 = LINE('',#30634,#30635); +#30634 = CARTESIAN_POINT('',(-35.29999999979,-58.59999173031,38.5)); +#30635 = VECTOR('',#30636,1.); +#30636 = DIRECTION('',(4.831970259692E-26,-8.583303420669E-39,-1.)); +#30637 = PCURVE('',#30573,#30638); +#30638 = DEFINITIONAL_REPRESENTATION('',(#30639),#30643); +#30639 = LINE('',#30640,#30641); +#30640 = CARTESIAN_POINT('',(5.497787143796,0.)); +#30641 = VECTOR('',#30642,1.); +#30642 = DIRECTION('',(0.,-1.)); +#30643 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30644 = PCURVE('',#30645,#30650); +#30645 = PLANE('',#30646); +#30646 = AXIS2_PLACEMENT_3D('',#30647,#30648,#30649); +#30647 = CARTESIAN_POINT('',(-34.99999999983,-58.59999173031,38.5)); +#30648 = DIRECTION('',(1.776356839832E-13,1.,-7.965459557598E-57)); +#30649 = DIRECTION('',(-1.,1.776356839832E-13,1.069123743598E-27)); +#30650 = DEFINITIONAL_REPRESENTATION('',(#30651),#30655); +#30651 = LINE('',#30652,#30653); +#30652 = CARTESIAN_POINT('',(0.299999999968,-3.207371230448E-28)); +#30653 = VECTOR('',#30654,1.); +#30654 = DIRECTION('',(-4.938882634052E-26,-1.)); +#30655 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30656 = ORIENTED_EDGE('',*,*,#30657,.T.); +#30657 = EDGE_CURVE('',#30630,#30658,#30660,.T.); +#30658 = VERTEX_POINT('',#30659); +#30659 = CARTESIAN_POINT('',(-36.7999999998,-60.09999173027,38.5)); +#30660 = SURFACE_CURVE('',#30661,(#30666,#30673),.PCURVE_S1.); +#30661 = CIRCLE('',#30662,1.5); +#30662 = AXIS2_PLACEMENT_3D('',#30663,#30664,#30665); +#30663 = CARTESIAN_POINT('',(-35.2999999998,-60.09999173031,38.5)); +#30664 = DIRECTION('',(1.420901018281E-27,1.980689724944E-15,1.)); +#30665 = DIRECTION('',(-0.707106781177,0.707106781196, + -1.400559135953E-15)); +#30666 = PCURVE('',#30573,#30667); +#30667 = DEFINITIONAL_REPRESENTATION('',(#30668),#30672); +#30668 = LINE('',#30669,#30670); +#30669 = CARTESIAN_POINT('',(1.7763568394E-15,-1.989519660128E-13)); +#30670 = VECTOR('',#30671,1.); +#30671 = DIRECTION('',(1.,0.)); +#30672 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30673 = PCURVE('',#30240,#30674); +#30674 = DEFINITIONAL_REPRESENTATION('',(#30675),#30679); +#30675 = CIRCLE('',#30676,1.5); +#30676 = AXIS2_PLACEMENT_2D('',#30677,#30678); +#30677 = CARTESIAN_POINT('',(33.299999999801,60.100000000272)); +#30678 = DIRECTION('',(0.707106781177,-0.707106781196)); +#30679 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30680 = ORIENTED_EDGE('',*,*,#30681,.T.); +#30681 = EDGE_CURVE('',#30658,#30562,#30682,.T.); +#30682 = SURFACE_CURVE('',#30683,(#30687,#30694),.PCURVE_S1.); +#30683 = LINE('',#30684,#30685); +#30684 = CARTESIAN_POINT('',(-36.7999999998,-60.09999173027,38.5)); +#30685 = VECTOR('',#30686,1.); +#30686 = DIRECTION('',(-4.831970259692E-26,8.583303420669E-39,1.)); +#30687 = PCURVE('',#30573,#30688); +#30688 = DEFINITIONAL_REPRESENTATION('',(#30689),#30693); +#30689 = LINE('',#30690,#30691); +#30690 = CARTESIAN_POINT('',(7.068583470564,0.)); +#30691 = VECTOR('',#30692,1.); +#30692 = DIRECTION('',(0.,1.)); +#30693 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30694 = PCURVE('',#30695,#30700); +#30695 = PLANE('',#30696); +#30696 = AXIS2_PLACEMENT_3D('',#30697,#30698,#30699); +#30697 = CARTESIAN_POINT('',(-36.79999999975,-58.59999173031,38.5)); +#30698 = DIRECTION('',(-1.,2.720157432627E-11,-4.831970259692E-26)); +#30699 = DIRECTION('',(-2.720157432627E-11,-1.,1.980689724944E-15)); +#30700 = DEFINITIONAL_REPRESENTATION('',(#30701),#30705); +#30701 = LINE('',#30702,#30703); +#30702 = CARTESIAN_POINT('',(1.499999999959,-2.971034587335E-15)); +#30703 = VECTOR('',#30704,1.); +#30704 = DIRECTION('',(1.980689724944E-15,1.)); +#30705 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30706 = ADVANCED_FACE('',(#30707),#30585,.T.); +#30707 = FACE_BOUND('',#30708,.T.); +#30708 = EDGE_LOOP('',(#30709,#30710,#30733,#30762,#30790,#30823,#30851, + #30884)); +#30709 = ORIENTED_EDGE('',*,*,#30561,.F.); +#30710 = ORIENTED_EDGE('',*,*,#30711,.T.); +#30711 = EDGE_CURVE('',#30562,#30712,#30714,.T.); +#30712 = VERTEX_POINT('',#30713); +#30713 = CARTESIAN_POINT('',(-36.79999999984,-61.59999173032,43.5)); +#30714 = SURFACE_CURVE('',#30715,(#30719,#30726),.PCURVE_S1.); +#30715 = LINE('',#30716,#30717); +#30716 = CARTESIAN_POINT('',(-36.79999999975,-58.59999173031,43.5)); +#30717 = VECTOR('',#30718,1.); +#30718 = DIRECTION('',(-2.720157432627E-11,-1.,1.980689724944E-15)); +#30719 = PCURVE('',#30585,#30720); +#30720 = DEFINITIONAL_REPRESENTATION('',(#30721),#30725); +#30721 = LINE('',#30722,#30723); +#30722 = CARTESIAN_POINT('',(4.89999999988,-4.899999999909)); +#30723 = VECTOR('',#30724,1.); +#30724 = DIRECTION('',(2.720157432627E-11,1.)); +#30725 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30726 = PCURVE('',#30695,#30727); +#30727 = DEFINITIONAL_REPRESENTATION('',(#30728),#30732); +#30728 = LINE('',#30729,#30730); +#30729 = CARTESIAN_POINT('',(9.903448624721E-15,5.)); +#30730 = VECTOR('',#30731,1.); +#30731 = DIRECTION('',(1.,0.)); +#30732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30733 = ORIENTED_EDGE('',*,*,#30734,.T.); +#30734 = EDGE_CURVE('',#30712,#30735,#30737,.T.); +#30735 = VERTEX_POINT('',#30736); +#30736 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,43.5)); +#30737 = SURFACE_CURVE('',#30738,(#30743,#30750),.PCURVE_S1.); +#30738 = CIRCLE('',#30739,6.79999999981); +#30739 = AXIS2_PLACEMENT_3D('',#30740,#30741,#30742); +#30740 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,43.5)); +#30741 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#30742 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30743 = PCURVE('',#30585,#30744); +#30744 = DEFINITIONAL_REPRESENTATION('',(#30745),#30749); +#30745 = CIRCLE('',#30746,6.79999999981); +#30746 = AXIS2_PLACEMENT_2D('',#30747,#30748); +#30747 = CARTESIAN_POINT('',(-1.899999999848,-1.899999999901)); +#30748 = DIRECTION('',(1.,8.723744686338E-59)); +#30749 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30750 = PCURVE('',#30751,#30756); +#30751 = CYLINDRICAL_SURFACE('',#30752,6.79999999981); +#30752 = AXIS2_PLACEMENT_3D('',#30753,#30754,#30755); +#30753 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,38.5)); +#30754 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30755 = DIRECTION('',(-1.,-2.52414075001E-42,4.48415508584E-44)); +#30756 = DEFINITIONAL_REPRESENTATION('',(#30757),#30761); +#30757 = LINE('',#30758,#30759); +#30758 = CARTESIAN_POINT('',(0.,5.)); +#30759 = VECTOR('',#30760,1.); +#30760 = DIRECTION('',(1.,0.)); +#30761 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30762 = ORIENTED_EDGE('',*,*,#30763,.T.); +#30763 = EDGE_CURVE('',#30735,#30764,#30766,.T.); +#30764 = VERTEX_POINT('',#30765); +#30765 = CARTESIAN_POINT('',(-28.49999999986,-68.39999173007,43.5)); +#30766 = SURFACE_CURVE('',#30767,(#30771,#30778),.PCURVE_S1.); +#30767 = LINE('',#30768,#30769); +#30768 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,43.5)); +#30769 = VECTOR('',#30770,1.); +#30770 = DIRECTION('',(1.,3.253693610712E-11,-6.586653994618E-26)); +#30771 = PCURVE('',#30585,#30772); +#30772 = DEFINITIONAL_REPRESENTATION('',(#30773),#30777); +#30773 = LINE('',#30774,#30775); +#30774 = CARTESIAN_POINT('',(-1.899999999848,4.899999999893)); +#30775 = VECTOR('',#30776,1.); +#30776 = DIRECTION('',(-1.,-3.253693610712E-11)); +#30777 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30778 = PCURVE('',#30779,#30784); +#30779 = PLANE('',#30780); +#30780 = AXIS2_PLACEMENT_3D('',#30781,#30782,#30783); +#30781 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,38.5)); +#30782 = DIRECTION('',(3.253693610712E-11,-1.,1.7763568394E-15)); +#30783 = DIRECTION('',(1.,3.253693610712E-11,-6.586653994618E-26)); +#30784 = DEFINITIONAL_REPRESENTATION('',(#30785),#30789); +#30785 = LINE('',#30786,#30787); +#30786 = CARTESIAN_POINT('',(1.330449721652E-25,5.)); +#30787 = VECTOR('',#30788,1.); +#30788 = DIRECTION('',(1.,0.)); +#30789 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30790 = ORIENTED_EDGE('',*,*,#30791,.F.); +#30791 = EDGE_CURVE('',#30792,#30764,#30794,.T.); +#30792 = VERTEX_POINT('',#30793); +#30793 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173002,43.5)); +#30794 = SURFACE_CURVE('',#30795,(#30800,#30811),.PCURVE_S1.); +#30795 = CIRCLE('',#30796,1.5); +#30796 = AXIS2_PLACEMENT_3D('',#30797,#30798,#30799); +#30797 = CARTESIAN_POINT('',(-28.49999999991,-66.89999173007,43.5)); +#30798 = DIRECTION('',(-1.42107472003E-27,-1.980689724944E-15,-1.)); +#30799 = DIRECTION('',(0.707106781198,-0.707106781175,1.400559135911E-15 + )); +#30800 = PCURVE('',#30585,#30801); +#30801 = DEFINITIONAL_REPRESENTATION('',(#30802),#30810); +#30802 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30803,#30804,#30805,#30806 + ,#30807,#30808,#30809),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30803 = CARTESIAN_POINT('',(-4.460660171759,4.460660171607)); +#30804 = CARTESIAN_POINT('',(-2.623542864702,6.297777478724)); +#30805 = CARTESIAN_POINT('',(-1.951111260535,3.788228567522)); +#30806 = CARTESIAN_POINT('',(-1.278679656368,1.278679656319)); +#30807 = CARTESIAN_POINT('',(-3.788228567592,1.951111260404)); +#30808 = CARTESIAN_POINT('',(-6.297777478817,2.62354286449)); +#30809 = CARTESIAN_POINT('',(-4.460660171759,4.460660171607)); +#30810 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30811 = PCURVE('',#30812,#30817); +#30812 = CYLINDRICAL_SURFACE('',#30813,1.5); +#30813 = AXIS2_PLACEMENT_3D('',#30814,#30815,#30816); +#30814 = CARTESIAN_POINT('',(-28.49999999991,-66.89999173007,38.5)); +#30815 = DIRECTION('',(-9.203377230688E-29,1.7763568394E-15,1.)); +#30816 = DIRECTION('',(0.707106781198,-0.707106781175,1.256073966927E-15 + )); +#30817 = DEFINITIONAL_REPRESENTATION('',(#30818),#30822); +#30818 = LINE('',#30819,#30820); +#30819 = CARTESIAN_POINT('',(6.28318530718,5.)); +#30820 = VECTOR('',#30821,1.); +#30821 = DIRECTION('',(-1.,0.)); +#30822 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30823 = ORIENTED_EDGE('',*,*,#30824,.T.); +#30824 = EDGE_CURVE('',#30792,#30825,#30827,.T.); +#30825 = VERTEX_POINT('',#30826); +#30826 = CARTESIAN_POINT('',(-30.00000000003,-66.89999173012,43.5)); +#30827 = SURFACE_CURVE('',#30828,(#30832,#30839),.PCURVE_S1.); +#30828 = LINE('',#30829,#30830); +#30829 = CARTESIAN_POINT('',(-30.00000000003,-66.89999173012,43.5)); +#30830 = VECTOR('',#30831,1.); +#30831 = DIRECTION('',(-1.,-3.253989670185E-11,6.587240396574E-26)); +#30832 = PCURVE('',#30585,#30833); +#30833 = DEFINITIONAL_REPRESENTATION('',(#30834),#30838); +#30834 = LINE('',#30835,#30836); +#30835 = CARTESIAN_POINT('',(-1.899999999848,3.399999999893)); +#30836 = VECTOR('',#30837,1.); +#30837 = DIRECTION('',(1.,3.253989670185E-11)); +#30838 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30839 = PCURVE('',#30840,#30845); +#30840 = PLANE('',#30841); +#30841 = AXIS2_PLACEMENT_3D('',#30842,#30843,#30844); +#30842 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173002,38.5)); +#30843 = DIRECTION('',(-3.253989670185E-11,1.,-1.7763568394E-15)); +#30844 = DIRECTION('',(-1.,-3.253989670185E-11,6.587240396574E-26)); +#30845 = DEFINITIONAL_REPRESENTATION('',(#30846),#30850); +#30846 = LINE('',#30847,#30848); +#30847 = CARTESIAN_POINT('',(3.000000000114,5.)); +#30848 = VECTOR('',#30849,1.); +#30849 = DIRECTION('',(1.,0.)); +#30850 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30851 = ORIENTED_EDGE('',*,*,#30852,.T.); +#30852 = EDGE_CURVE('',#30825,#30853,#30855,.T.); +#30853 = VERTEX_POINT('',#30854); +#30854 = CARTESIAN_POINT('',(-35.29999999984,-61.59999173032,43.5)); +#30855 = SURFACE_CURVE('',#30856,(#30861,#30872),.PCURVE_S1.); +#30856 = CIRCLE('',#30857,5.29999999981); +#30857 = AXIS2_PLACEMENT_3D('',#30858,#30859,#30860); +#30858 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,43.5)); +#30859 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#30860 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#30861 = PCURVE('',#30585,#30862); +#30862 = DEFINITIONAL_REPRESENTATION('',(#30863),#30871); +#30863 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#30864,#30865,#30866,#30867 + ,#30868,#30869,#30870),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#30864 = CARTESIAN_POINT('',(3.399999999962,-1.899999999901)); +#30865 = CARTESIAN_POINT('',(3.399999999962,-11.07986927968)); +#30866 = CARTESIAN_POINT('',(-4.549999999754,-6.489934639795)); +#30867 = CARTESIAN_POINT('',(-12.49999999946,-1.899999999901)); +#30868 = CARTESIAN_POINT('',(-4.549999999754,2.689934639992)); +#30869 = CARTESIAN_POINT('',(3.399999999962,7.279869279885)); +#30870 = CARTESIAN_POINT('',(3.399999999962,-1.899999999901)); +#30871 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30872 = PCURVE('',#30873,#30878); +#30873 = CYLINDRICAL_SURFACE('',#30874,5.29999999981); +#30874 = AXIS2_PLACEMENT_3D('',#30875,#30876,#30877); +#30875 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,38.5)); +#30876 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30877 = DIRECTION('',(-1.,-2.52414075001E-42,4.48415508584E-44)); +#30878 = DEFINITIONAL_REPRESENTATION('',(#30879),#30883); +#30879 = LINE('',#30880,#30881); +#30880 = CARTESIAN_POINT('',(6.28318530718,5.)); +#30881 = VECTOR('',#30882,1.); +#30882 = DIRECTION('',(-1.,4.52345554697E-15)); +#30883 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30884 = ORIENTED_EDGE('',*,*,#30885,.T.); +#30885 = EDGE_CURVE('',#30853,#30564,#30886,.T.); +#30886 = SURFACE_CURVE('',#30887,(#30891,#30898),.PCURVE_S1.); +#30887 = LINE('',#30888,#30889); +#30888 = CARTESIAN_POINT('',(-35.29999999975,-58.59999173031,43.5)); +#30889 = VECTOR('',#30890,1.); +#30890 = DIRECTION('',(2.72026845493E-11,1.,-1.980689724944E-15)); +#30891 = PCURVE('',#30585,#30892); +#30892 = DEFINITIONAL_REPRESENTATION('',(#30893),#30897); +#30893 = LINE('',#30894,#30895); +#30894 = CARTESIAN_POINT('',(3.39999999988,-4.899999999909)); +#30895 = VECTOR('',#30896,1.); +#30896 = DIRECTION('',(-2.72026845493E-11,-1.)); +#30897 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30898 = PCURVE('',#30617,#30899); +#30899 = DEFINITIONAL_REPRESENTATION('',(#30900),#30904); +#30900 = LINE('',#30901,#30902); +#30901 = CARTESIAN_POINT('',(3.000000000008,5.)); +#30902 = VECTOR('',#30903,1.); +#30903 = DIRECTION('',(1.,0.)); +#30904 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30905 = ADVANCED_FACE('',(#30906),#30695,.T.); +#30906 = FACE_BOUND('',#30907,.T.); +#30907 = EDGE_LOOP('',(#30908,#30909,#30932,#30953)); +#30908 = ORIENTED_EDGE('',*,*,#30681,.F.); +#30909 = ORIENTED_EDGE('',*,*,#30910,.T.); +#30910 = EDGE_CURVE('',#30658,#30911,#30913,.T.); +#30911 = VERTEX_POINT('',#30912); +#30912 = CARTESIAN_POINT('',(-36.79999999984,-61.59999173032,38.5)); +#30913 = SURFACE_CURVE('',#30914,(#30918,#30925),.PCURVE_S1.); +#30914 = LINE('',#30915,#30916); +#30915 = CARTESIAN_POINT('',(-36.79999999975,-58.59999173031,38.5)); +#30916 = VECTOR('',#30917,1.); +#30917 = DIRECTION('',(-2.720157432627E-11,-1.,1.980689724944E-15)); +#30918 = PCURVE('',#30695,#30919); +#30919 = DEFINITIONAL_REPRESENTATION('',(#30920),#30924); +#30920 = LINE('',#30921,#30922); +#30921 = CARTESIAN_POINT('',(0.,0.)); +#30922 = VECTOR('',#30923,1.); +#30923 = DIRECTION('',(1.,0.)); +#30924 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30925 = PCURVE('',#30240,#30926); +#30926 = DEFINITIONAL_REPRESENTATION('',(#30927),#30931); +#30927 = LINE('',#30928,#30929); +#30928 = CARTESIAN_POINT('',(34.79999999976,58.600000000272)); +#30929 = VECTOR('',#30930,1.); +#30930 = DIRECTION('',(2.720157432627E-11,1.)); +#30931 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30932 = ORIENTED_EDGE('',*,*,#30933,.T.); +#30933 = EDGE_CURVE('',#30911,#30712,#30934,.T.); +#30934 = SURFACE_CURVE('',#30935,(#30939,#30946),.PCURVE_S1.); +#30935 = LINE('',#30936,#30937); +#30936 = CARTESIAN_POINT('',(-36.79999999984,-61.59999173032,38.5)); +#30937 = VECTOR('',#30938,1.); +#30938 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#30939 = PCURVE('',#30695,#30940); +#30940 = DEFINITIONAL_REPRESENTATION('',(#30941),#30945); +#30941 = LINE('',#30942,#30943); +#30942 = CARTESIAN_POINT('',(3.000000000008,-5.942069174848E-15)); +#30943 = VECTOR('',#30944,1.); +#30944 = DIRECTION('',(2.043328855439E-16,1.)); +#30945 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30946 = PCURVE('',#30751,#30947); +#30947 = DEFINITIONAL_REPRESENTATION('',(#30948),#30952); +#30948 = LINE('',#30949,#30950); +#30949 = CARTESIAN_POINT('',(0.,0.)); +#30950 = VECTOR('',#30951,1.); +#30951 = DIRECTION('',(0.,1.)); +#30952 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30953 = ORIENTED_EDGE('',*,*,#30711,.F.); +#30954 = ADVANCED_FACE('',(#30955,#31818,#31932,#31963,#31994,#32025, + #32056,#32087),#30240,.F.); +#30955 = FACE_BOUND('',#30956,.T.); +#30956 = EDGE_LOOP('',(#30957,#30958,#30959,#30982,#31010,#31039,#31067, + #31096,#31124,#31153,#31181,#31209,#31237,#31261,#31284,#31306, + #31307,#31308,#31331,#31359,#31387,#31415,#31443,#31471,#31499, + #31528,#31556,#31585,#31613,#31642,#31670,#31698,#31726,#31750, + #31773,#31797)); +#30957 = ORIENTED_EDGE('',*,*,#30223,.F.); +#30958 = ORIENTED_EDGE('',*,*,#30338,.F.); +#30959 = ORIENTED_EDGE('',*,*,#30960,.F.); +#30960 = EDGE_CURVE('',#30961,#30311,#30963,.T.); +#30961 = VERTEX_POINT('',#30962); +#30962 = CARTESIAN_POINT('',(31.000000000244,-58.59999173036,38.5)); +#30963 = SURFACE_CURVE('',#30964,(#30968,#30975),.PCURVE_S1.); +#30964 = LINE('',#30965,#30966); +#30965 = CARTESIAN_POINT('',(31.000000000246,-61.5999917304,38.5)); +#30966 = VECTOR('',#30967,1.); +#30967 = DIRECTION('',(-9.503220721166E-13,1.,-1.980689724944E-15)); +#30968 = PCURVE('',#30240,#30969); +#30969 = DEFINITIONAL_REPRESENTATION('',(#30970),#30974); +#30970 = LINE('',#30971,#30972); +#30971 = CARTESIAN_POINT('',(-33.00000000024,61.600000000358)); +#30972 = VECTOR('',#30973,1.); +#30973 = DIRECTION('',(9.503220721166E-13,-1.)); +#30974 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30975 = PCURVE('',#30326,#30976); +#30976 = DEFINITIONAL_REPRESENTATION('',(#30977),#30981); +#30977 = LINE('',#30978,#30979); +#30978 = CARTESIAN_POINT('',(-3.000000000041,-5.942069174913E-15)); +#30979 = VECTOR('',#30980,1.); +#30980 = DIRECTION('',(1.,0.)); +#30981 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30982 = ORIENTED_EDGE('',*,*,#30983,.F.); +#30983 = EDGE_CURVE('',#30984,#30961,#30986,.T.); +#30984 = VERTEX_POINT('',#30985); +#30985 = CARTESIAN_POINT('',(31.30000000017,-58.59999173036,38.5)); +#30986 = SURFACE_CURVE('',#30987,(#30991,#30998),.PCURVE_S1.); +#30987 = LINE('',#30988,#30989); +#30988 = CARTESIAN_POINT('',(32.800000000171,-58.59999173036,38.5)); +#30989 = VECTOR('',#30990,1.); +#30990 = DIRECTION('',(-1.,7.283063041522E-13,-2.158389484236E-29)); +#30991 = PCURVE('',#30240,#30992); +#30992 = DEFINITIONAL_REPRESENTATION('',(#30993),#30997); +#30993 = LINE('',#30994,#30995); +#30994 = CARTESIAN_POINT('',(-34.80000000017,58.600000000319)); +#30995 = VECTOR('',#30996,1.); +#30996 = DIRECTION('',(1.,-7.283063041522E-13)); +#30997 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#30998 = PCURVE('',#30999,#31004); +#30999 = PLANE('',#31000); +#31000 = AXIS2_PLACEMENT_3D('',#31001,#31002,#31003); +#31001 = CARTESIAN_POINT('',(31.300000000167,-58.59999173036,38.5)); +#31002 = DIRECTION('',(1.273055734871E-12,1.,-5.708579348079E-56)); +#31003 = DIRECTION('',(-1.,1.273055734871E-12,-1.100563495693E-27)); +#31004 = DEFINITIONAL_REPRESENTATION('',(#31005),#31009); +#31005 = LINE('',#31006,#31007); +#31006 = CARTESIAN_POINT('',(-1.500000000004,-1.650845243544E-27)); +#31007 = VECTOR('',#31008,1.); +#31008 = DIRECTION('',(1.,1.078979600851E-27)); +#31009 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31010 = ORIENTED_EDGE('',*,*,#31011,.F.); +#31011 = EDGE_CURVE('',#31012,#30984,#31014,.T.); +#31012 = VERTEX_POINT('',#31013); +#31013 = CARTESIAN_POINT('',(32.800000000168,-60.09999173036,38.5)); +#31014 = SURFACE_CURVE('',#31015,(#31020,#31027),.PCURVE_S1.); +#31015 = CIRCLE('',#31016,1.5); +#31016 = AXIS2_PLACEMENT_3D('',#31017,#31018,#31019); +#31017 = CARTESIAN_POINT('',(31.300000000168,-60.09999173036,38.5)); +#31018 = DIRECTION('',(1.421037928292E-27,1.980689724944E-15,1.)); +#31019 = DIRECTION('',(0.707106781187,0.707106781186,-1.400559135935E-15 + )); +#31020 = PCURVE('',#30240,#31021); +#31021 = DEFINITIONAL_REPRESENTATION('',(#31022),#31026); +#31022 = CIRCLE('',#31023,1.5); +#31023 = AXIS2_PLACEMENT_2D('',#31024,#31025); +#31024 = CARTESIAN_POINT('',(-33.30000000016,60.100000000318)); +#31025 = DIRECTION('',(-0.707106781187,-0.707106781186)); +#31026 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31027 = PCURVE('',#31028,#31033); +#31028 = CYLINDRICAL_SURFACE('',#31029,1.5); +#31029 = AXIS2_PLACEMENT_3D('',#31030,#31031,#31032); +#31030 = CARTESIAN_POINT('',(31.300000000168,-60.09999173036,38.5)); +#31031 = DIRECTION('',(3.996895253057E-28,-5.088270423583E-40,1.)); +#31032 = DIRECTION('',(0.707106781187,0.707106781186,-2.826231737127E-28 + )); +#31033 = DEFINITIONAL_REPRESENTATION('',(#31034),#31038); +#31034 = LINE('',#31035,#31036); +#31035 = CARTESIAN_POINT('',(-6.28318530718,-1.989519660128E-13)); +#31036 = VECTOR('',#31037,1.); +#31037 = DIRECTION('',(1.,0.)); +#31038 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31039 = ORIENTED_EDGE('',*,*,#31040,.F.); +#31040 = EDGE_CURVE('',#31041,#31012,#31043,.T.); +#31041 = VERTEX_POINT('',#31042); +#31042 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,38.5)); +#31043 = SURFACE_CURVE('',#31044,(#31048,#31055),.PCURVE_S1.); +#31044 = LINE('',#31045,#31046); +#31045 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,38.5)); +#31046 = VECTOR('',#31047,1.); +#31047 = DIRECTION('',(-2.250051996538E-13,1.,-1.980689724944E-15)); +#31048 = PCURVE('',#30240,#31049); +#31049 = DEFINITIONAL_REPRESENTATION('',(#31050),#31054); +#31050 = LINE('',#31051,#31052); +#31051 = CARTESIAN_POINT('',(-34.80000000016,61.600000000365)); +#31052 = VECTOR('',#31053,1.); +#31053 = DIRECTION('',(2.250051996538E-13,-1.)); +#31054 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31055 = PCURVE('',#31056,#31061); +#31056 = PLANE('',#31057); +#31057 = AXIS2_PLACEMENT_3D('',#31058,#31059,#31060); +#31058 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,38.5)); +#31059 = DIRECTION('',(1.,2.250051996538E-13,-3.996895253057E-28)); +#31060 = DIRECTION('',(-2.250051996538E-13,1.,-1.980689724944E-15)); +#31061 = DEFINITIONAL_REPRESENTATION('',(#31062),#31066); +#31062 = LINE('',#31063,#31064); +#31063 = CARTESIAN_POINT('',(0.,0.)); +#31064 = VECTOR('',#31065,1.); +#31065 = DIRECTION('',(1.,0.)); +#31066 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31067 = ORIENTED_EDGE('',*,*,#31068,.F.); +#31068 = EDGE_CURVE('',#31069,#31041,#31071,.T.); +#31069 = VERTEX_POINT('',#31070); +#31070 = CARTESIAN_POINT('',(26.000070869049,-68.39999173014,38.5)); +#31071 = SURFACE_CURVE('',#31072,(#31077,#31084),.PCURVE_S1.); +#31072 = CIRCLE('',#31073,6.800000000105); +#31073 = AXIS2_PLACEMENT_3D('',#31074,#31075,#31076); +#31074 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,38.5)); +#31075 = DIRECTION('',(1.420964916416E-27,1.980689724944E-15,1.)); +#31076 = DIRECTION('',(1.042190969326E-05,-0.999999999946, + 1.980689724837E-15)); +#31077 = PCURVE('',#30240,#31078); +#31078 = DEFINITIONAL_REPRESENTATION('',(#31079),#31083); +#31079 = CIRCLE('',#31080,6.800000000105); +#31080 = AXIS2_PLACEMENT_2D('',#31081,#31082); +#31081 = CARTESIAN_POINT('',(-28.00000000006,61.60000000036)); +#31082 = DIRECTION('',(-1.042190969326E-05,0.999999999946)); +#31083 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31084 = PCURVE('',#31085,#31090); +#31085 = CYLINDRICAL_SURFACE('',#31086,6.800000000105); +#31086 = AXIS2_PLACEMENT_3D('',#31087,#31088,#31089); +#31087 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,38.5)); +#31088 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#31089 = DIRECTION('',(1.042190969326E-05,-0.999999999946, + 1.776356839304E-15)); +#31090 = DEFINITIONAL_REPRESENTATION('',(#31091),#31095); +#31091 = LINE('',#31092,#31093); +#31092 = CARTESIAN_POINT('',(0.,0.)); +#31093 = VECTOR('',#31094,1.); +#31094 = DIRECTION('',(1.,0.)); +#31095 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31096 = ORIENTED_EDGE('',*,*,#31097,.F.); +#31097 = EDGE_CURVE('',#31098,#31069,#31100,.T.); +#31098 = VERTEX_POINT('',#31099); +#31099 = CARTESIAN_POINT('',(24.500000000085,-68.39999173014,38.5)); +#31100 = SURFACE_CURVE('',#31101,(#31105,#31112),.PCURVE_S1.); +#31101 = LINE('',#31102,#31103); +#31102 = CARTESIAN_POINT('',(23.000000000085,-68.39999173014,38.5)); +#31103 = VECTOR('',#31104,1.); +#31104 = DIRECTION('',(1.,-2.418748758244E-12,3.369825895028E-27)); +#31105 = PCURVE('',#30240,#31106); +#31106 = DEFINITIONAL_REPRESENTATION('',(#31107),#31111); +#31107 = LINE('',#31108,#31109); +#31108 = CARTESIAN_POINT('',(-25.00000000008,68.400000000094)); +#31109 = VECTOR('',#31110,1.); +#31110 = DIRECTION('',(-1.,2.418748758244E-12)); +#31111 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31112 = PCURVE('',#31113,#31118); +#31113 = PLANE('',#31114); +#31114 = AXIS2_PLACEMENT_3D('',#31115,#31116,#31117); +#31115 = CARTESIAN_POINT('',(23.000000000085,-68.39999173014,38.5)); +#31116 = DIRECTION('',(-2.418748758244E-12,-1.,1.7763568394E-15)); +#31117 = DIRECTION('',(1.,-2.418748758244E-12,3.369825895028E-27)); +#31118 = DEFINITIONAL_REPRESENTATION('',(#31119),#31123); +#31119 = LINE('',#31120,#31121); +#31120 = CARTESIAN_POINT('',(0.,0.)); +#31121 = VECTOR('',#31122,1.); +#31122 = DIRECTION('',(1.,0.)); +#31123 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31124 = ORIENTED_EDGE('',*,*,#31125,.F.); +#31125 = EDGE_CURVE('',#31126,#31098,#31128,.T.); +#31126 = VERTEX_POINT('',#31127); +#31127 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,38.5)); +#31128 = SURFACE_CURVE('',#31129,(#31134,#31141),.PCURVE_S1.); +#31129 = CIRCLE('',#31130,1.5); +#31130 = AXIS2_PLACEMENT_3D('',#31131,#31132,#31133); +#31131 = CARTESIAN_POINT('',(24.500000000089,-66.89999173014,38.5)); +#31132 = DIRECTION('',(1.421038649714E-27,1.980689724944E-15,1.)); +#31133 = DIRECTION('',(-0.707106781188,-0.707106781185, + 1.400559135932E-15)); +#31134 = PCURVE('',#30240,#31135); +#31135 = DEFINITIONAL_REPRESENTATION('',(#31136),#31140); +#31136 = CIRCLE('',#31137,1.5); +#31137 = AXIS2_PLACEMENT_2D('',#31138,#31139); +#31138 = CARTESIAN_POINT('',(-26.50000000008,66.900000000098)); +#31139 = DIRECTION('',(0.707106781188,0.707106781185)); +#31140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31141 = PCURVE('',#31142,#31147); +#31142 = CYLINDRICAL_SURFACE('',#31143,1.5); +#31143 = AXIS2_PLACEMENT_3D('',#31144,#31145,#31146); +#31144 = CARTESIAN_POINT('',(24.500000000089,-66.89999173014,38.5)); +#31145 = DIRECTION('',(4.259848892852E-27,1.7763568394E-15,1.)); +#31146 = DIRECTION('',(-0.707106781188,-0.707106781185, + 1.256073966947E-15)); +#31147 = DEFINITIONAL_REPRESENTATION('',(#31148),#31152); +#31148 = LINE('',#31149,#31150); +#31149 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#31150 = VECTOR('',#31151,1.); +#31151 = DIRECTION('',(1.,0.)); +#31152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31153 = ORIENTED_EDGE('',*,*,#31154,.F.); +#31154 = EDGE_CURVE('',#31155,#31126,#31157,.T.); +#31155 = VERTEX_POINT('',#31156); +#31156 = CARTESIAN_POINT('',(23.00000000009,-66.59999173055,38.5)); +#31157 = SURFACE_CURVE('',#31158,(#31162,#31169),.PCURVE_S1.); +#31158 = LINE('',#31159,#31160); +#31159 = CARTESIAN_POINT('',(23.00000000009,-66.59999173046,38.5)); +#31160 = VECTOR('',#31161,1.); +#31161 = DIRECTION('',(-2.398081735813E-12,-1.,1.980689724944E-15)); +#31162 = PCURVE('',#30240,#31163); +#31163 = DEFINITIONAL_REPRESENTATION('',(#31164),#31168); +#31164 = LINE('',#31165,#31166); +#31165 = CARTESIAN_POINT('',(-25.00000000008,66.600000000422)); +#31166 = VECTOR('',#31167,1.); +#31167 = DIRECTION('',(2.398081735813E-12,1.)); +#31168 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31169 = PCURVE('',#31170,#31175); +#31170 = PLANE('',#31171); +#31171 = AXIS2_PLACEMENT_3D('',#31172,#31173,#31174); +#31172 = CARTESIAN_POINT('',(23.00000000009,-66.59999173055,38.5)); +#31173 = DIRECTION('',(-1.,2.398081735813E-12,4.484155085839E-44)); +#31174 = DIRECTION('',(-2.398081735813E-12,-1.,1.980689724944E-15)); +#31175 = DEFINITIONAL_REPRESENTATION('',(#31176),#31180); +#31176 = LINE('',#31177,#31178); +#31177 = CARTESIAN_POINT('',(-8.559197794966E-11,1.695311512625E-25)); +#31178 = VECTOR('',#31179,1.); +#31179 = DIRECTION('',(1.,0.)); +#31180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31181 = ORIENTED_EDGE('',*,*,#31182,.F.); +#31182 = EDGE_CURVE('',#31183,#31155,#31185,.T.); +#31183 = VERTEX_POINT('',#31184); +#31184 = CARTESIAN_POINT('',(-26.99999999991,-66.59999173008,38.5)); +#31185 = SURFACE_CURVE('',#31186,(#31190,#31197),.PCURVE_S1.); +#31186 = LINE('',#31187,#31188); +#31187 = CARTESIAN_POINT('',(-30.00000000006,-66.59999173005,38.5)); +#31188 = VECTOR('',#31189,1.); +#31189 = DIRECTION('',(1.,-9.347443454171E-12,1.709340972143E-26)); +#31190 = PCURVE('',#30240,#31191); +#31191 = DEFINITIONAL_REPRESENTATION('',(#31192),#31196); +#31192 = LINE('',#31193,#31194); +#31193 = CARTESIAN_POINT('',(28.000000000066,66.600000000013)); +#31194 = VECTOR('',#31195,1.); +#31195 = DIRECTION('',(-1.,9.347443454171E-12)); +#31196 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31197 = PCURVE('',#31198,#31203); +#31198 = PLANE('',#31199); +#31199 = AXIS2_PLACEMENT_3D('',#31200,#31201,#31202); +#31200 = CARTESIAN_POINT('',(-26.99999999991,-66.59999173008,38.5)); +#31201 = DIRECTION('',(-9.347443454171E-12,-1.,4.191538610462E-55)); +#31202 = DIRECTION('',(1.,-9.347443454171E-12,1.709340972143E-26)); +#31203 = DEFINITIONAL_REPRESENTATION('',(#31204),#31208); +#31204 = LINE('',#31205,#31206); +#31205 = CARTESIAN_POINT('',(-3.000000000148,5.128022916681E-26)); +#31206 = VECTOR('',#31207,1.); +#31207 = DIRECTION('',(1.,0.)); +#31208 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31209 = ORIENTED_EDGE('',*,*,#31210,.F.); +#31210 = EDGE_CURVE('',#31211,#31183,#31213,.T.); +#31211 = VERTEX_POINT('',#31212); +#31212 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173007,38.5)); +#31213 = SURFACE_CURVE('',#31214,(#31218,#31225),.PCURVE_S1.); +#31214 = LINE('',#31215,#31216); +#31215 = CARTESIAN_POINT('',(-26.99999999991,-68.39999173002,38.5)); +#31216 = VECTOR('',#31217,1.); +#31217 = DIRECTION('',(1.480297366167E-15,1.,-1.980689724944E-15)); +#31218 = PCURVE('',#30240,#31219); +#31219 = DEFINITIONAL_REPRESENTATION('',(#31220),#31224); +#31220 = LINE('',#31221,#31222); +#31221 = CARTESIAN_POINT('',(24.999999999918,68.399999999977)); +#31222 = VECTOR('',#31223,1.); +#31223 = DIRECTION('',(-1.480297366167E-15,-1.)); +#31224 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31225 = PCURVE('',#31226,#31231); +#31226 = PLANE('',#31227); +#31227 = AXIS2_PLACEMENT_3D('',#31228,#31229,#31230); +#31228 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173002,38.5)); +#31229 = DIRECTION('',(1.,5.181040783335E-14,-4.484155085839E-44)); +#31230 = DIRECTION('',(-5.181040783335E-14,1.,-1.980689724944E-15)); +#31231 = DEFINITIONAL_REPRESENTATION('',(#31232),#31236); +#31232 = LINE('',#31233,#31234); +#31233 = CARTESIAN_POINT('',(-1.5,-2.971034587416E-15)); +#31234 = VECTOR('',#31235,1.); +#31235 = DIRECTION('',(1.,0.)); +#31236 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31237 = ORIENTED_EDGE('',*,*,#31238,.F.); +#31238 = EDGE_CURVE('',#31239,#31211,#31241,.T.); +#31239 = VERTEX_POINT('',#31240); +#31240 = CARTESIAN_POINT('',(-28.49999999986,-68.39999173007,38.5)); +#31241 = SURFACE_CURVE('',#31242,(#31247,#31254),.PCURVE_S1.); +#31242 = CIRCLE('',#31243,1.5); +#31243 = AXIS2_PLACEMENT_3D('',#31244,#31245,#31246); +#31244 = CARTESIAN_POINT('',(-28.49999999991,-66.89999173007,38.5)); +#31245 = DIRECTION('',(1.42107472003E-27,1.980689724944E-15,1.)); +#31246 = DIRECTION('',(0.707106781198,-0.707106781175,1.400559135911E-15 + )); +#31247 = PCURVE('',#30240,#31248); +#31248 = DEFINITIONAL_REPRESENTATION('',(#31249),#31253); +#31249 = CIRCLE('',#31250,1.5); +#31250 = AXIS2_PLACEMENT_2D('',#31251,#31252); +#31251 = CARTESIAN_POINT('',(26.499999999918,66.900000000025)); +#31252 = DIRECTION('',(-0.707106781198,0.707106781175)); +#31253 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31254 = PCURVE('',#30812,#31255); +#31255 = DEFINITIONAL_REPRESENTATION('',(#31256),#31260); +#31256 = LINE('',#31257,#31258); +#31257 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#31258 = VECTOR('',#31259,1.); +#31259 = DIRECTION('',(1.,0.)); +#31260 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31261 = ORIENTED_EDGE('',*,*,#31262,.F.); +#31262 = EDGE_CURVE('',#31263,#31239,#31265,.T.); +#31263 = VERTEX_POINT('',#31264); +#31264 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,38.5)); +#31265 = SURFACE_CURVE('',#31266,(#31270,#31277),.PCURVE_S1.); +#31266 = LINE('',#31267,#31268); +#31267 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,38.5)); +#31268 = VECTOR('',#31269,1.); +#31269 = DIRECTION('',(1.,3.253693610712E-11,-6.586653994618E-26)); +#31270 = PCURVE('',#30240,#31271); +#31271 = DEFINITIONAL_REPRESENTATION('',(#31272),#31276); +#31272 = LINE('',#31273,#31274); +#31273 = CARTESIAN_POINT('',(28.000000000031,68.400000000074)); +#31274 = VECTOR('',#31275,1.); +#31275 = DIRECTION('',(-1.,-3.253693610712E-11)); +#31276 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31277 = PCURVE('',#30779,#31278); +#31278 = DEFINITIONAL_REPRESENTATION('',(#31279),#31283); +#31279 = LINE('',#31280,#31281); +#31280 = CARTESIAN_POINT('',(0.,0.)); +#31281 = VECTOR('',#31282,1.); +#31282 = DIRECTION('',(1.,0.)); +#31283 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31284 = ORIENTED_EDGE('',*,*,#31285,.F.); +#31285 = EDGE_CURVE('',#30911,#31263,#31286,.T.); +#31286 = SURFACE_CURVE('',#31287,(#31292,#31299),.PCURVE_S1.); +#31287 = CIRCLE('',#31288,6.79999999981); +#31288 = AXIS2_PLACEMENT_3D('',#31289,#31290,#31291); +#31289 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,38.5)); +#31290 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#31291 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#31292 = PCURVE('',#30240,#31293); +#31293 = DEFINITIONAL_REPRESENTATION('',(#31294),#31298); +#31294 = CIRCLE('',#31295,6.79999999981); +#31295 = AXIS2_PLACEMENT_2D('',#31296,#31297); +#31296 = CARTESIAN_POINT('',(28.000000000031,61.60000000028)); +#31297 = DIRECTION('',(1.,8.723744686338E-59)); +#31298 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31299 = PCURVE('',#30751,#31300); +#31300 = DEFINITIONAL_REPRESENTATION('',(#31301),#31305); +#31301 = LINE('',#31302,#31303); +#31302 = CARTESIAN_POINT('',(0.,0.)); +#31303 = VECTOR('',#31304,1.); +#31304 = DIRECTION('',(1.,0.)); +#31305 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31306 = ORIENTED_EDGE('',*,*,#30910,.F.); +#31307 = ORIENTED_EDGE('',*,*,#30657,.F.); +#31308 = ORIENTED_EDGE('',*,*,#31309,.F.); +#31309 = EDGE_CURVE('',#31310,#30630,#31312,.T.); +#31310 = VERTEX_POINT('',#31311); +#31311 = CARTESIAN_POINT('',(-34.99999999979,-58.59999173031,38.5)); +#31312 = SURFACE_CURVE('',#31313,(#31317,#31324),.PCURVE_S1.); +#31313 = LINE('',#31314,#31315); +#31314 = CARTESIAN_POINT('',(-34.99999999983,-58.59999173031,38.5)); +#31315 = VECTOR('',#31316,1.); +#31316 = DIRECTION('',(-1.,1.776356839832E-13,1.069123743598E-27)); +#31317 = PCURVE('',#30240,#31318); +#31318 = DEFINITIONAL_REPRESENTATION('',(#31319),#31323); +#31319 = LINE('',#31320,#31321); +#31320 = CARTESIAN_POINT('',(32.999999999833,58.600000000272)); +#31321 = VECTOR('',#31322,1.); +#31322 = DIRECTION('',(1.,-1.776356839832E-13)); +#31323 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31324 = PCURVE('',#30645,#31325); +#31325 = DEFINITIONAL_REPRESENTATION('',(#31326),#31330); +#31326 = LINE('',#31327,#31328); +#31327 = CARTESIAN_POINT('',(0.,0.)); +#31328 = VECTOR('',#31329,1.); +#31329 = DIRECTION('',(1.,0.)); +#31330 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31331 = ORIENTED_EDGE('',*,*,#31332,.F.); +#31332 = EDGE_CURVE('',#31333,#31310,#31335,.T.); +#31333 = VERTEX_POINT('',#31334); +#31334 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,38.5)); +#31335 = SURFACE_CURVE('',#31336,(#31340,#31347),.PCURVE_S1.); +#31336 = LINE('',#31337,#31338); +#31337 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,38.5)); +#31338 = VECTOR('',#31339,1.); +#31339 = DIRECTION('',(9.121092769944E-12,-1.,1.980689724944E-15)); +#31340 = PCURVE('',#30240,#31341); +#31341 = DEFINITIONAL_REPRESENTATION('',(#31342),#31346); +#31342 = LINE('',#31343,#31344); +#31343 = CARTESIAN_POINT('',(32.999999999947,41.600000000284)); +#31344 = VECTOR('',#31345,1.); +#31345 = DIRECTION('',(-9.121092769944E-12,1.)); +#31346 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31347 = PCURVE('',#31348,#31353); +#31348 = PLANE('',#31349); +#31349 = AXIS2_PLACEMENT_3D('',#31350,#31351,#31352); +#31350 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,38.5)); +#31351 = DIRECTION('',(-1.,-9.121092769944E-12,4.484155085839E-44)); +#31352 = DIRECTION('',(9.121092769944E-12,-1.,1.980689724944E-15)); +#31353 = DEFINITIONAL_REPRESENTATION('',(#31354),#31358); +#31354 = LINE('',#31355,#31356); +#31355 = CARTESIAN_POINT('',(0.,0.)); +#31356 = VECTOR('',#31357,1.); +#31357 = DIRECTION('',(1.,0.)); +#31358 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31359 = ORIENTED_EDGE('',*,*,#31360,.T.); +#31360 = EDGE_CURVE('',#31333,#31361,#31363,.T.); +#31361 = VERTEX_POINT('',#31362); +#31362 = CARTESIAN_POINT('',(-24.99999999981,-41.59999173033,38.5)); +#31363 = SURFACE_CURVE('',#31364,(#31368,#31375),.PCURVE_S1.); +#31364 = LINE('',#31365,#31366); +#31365 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,38.5)); +#31366 = VECTOR('',#31367,1.); +#31367 = DIRECTION('',(1.,-6.910028105177E-13,-5.2320407293E-29)); +#31368 = PCURVE('',#30240,#31369); +#31369 = DEFINITIONAL_REPRESENTATION('',(#31370),#31374); +#31370 = LINE('',#31371,#31372); +#31371 = CARTESIAN_POINT('',(32.999999999947,41.600000000284)); +#31372 = VECTOR('',#31373,1.); +#31373 = DIRECTION('',(-1.,6.910028105177E-13)); +#31374 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31375 = PCURVE('',#31376,#31381); +#31376 = PLANE('',#31377); +#31377 = AXIS2_PLACEMENT_3D('',#31378,#31379,#31380); +#31378 = CARTESIAN_POINT('',(-24.99999999981,-41.59999173033,38.5)); +#31379 = DIRECTION('',(6.910028105177E-13,1.,-3.098563767112E-56)); +#31380 = DIRECTION('',(-1.,6.910028105177E-13,5.2320407293E-29)); +#31381 = DEFINITIONAL_REPRESENTATION('',(#31382),#31386); +#31382 = LINE('',#31383,#31384); +#31383 = CARTESIAN_POINT('',(10.00000000013,-5.232040729368E-28)); +#31384 = VECTOR('',#31385,1.); +#31385 = DIRECTION('',(-1.,0.)); +#31386 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31387 = ORIENTED_EDGE('',*,*,#31388,.F.); +#31388 = EDGE_CURVE('',#31389,#31361,#31391,.T.); +#31389 = VERTEX_POINT('',#31390); +#31390 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,38.5)); +#31391 = SURFACE_CURVE('',#31392,(#31396,#31403),.PCURVE_S1.); +#31392 = LINE('',#31393,#31394); +#31393 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,38.5)); +#31394 = VECTOR('',#31395,1.); +#31395 = DIRECTION('',(-7.105427357611E-14,-1.,1.980689724944E-15)); +#31396 = PCURVE('',#30240,#31397); +#31397 = DEFINITIONAL_REPRESENTATION('',(#31398),#31402); +#31398 = LINE('',#31399,#31400); +#31399 = CARTESIAN_POINT('',(22.999999999817,-41.59999999974)); +#31400 = VECTOR('',#31401,1.); +#31401 = DIRECTION('',(7.105427357611E-14,1.)); +#31402 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31403 = PCURVE('',#31404,#31409); +#31404 = PLANE('',#31405); +#31405 = AXIS2_PLACEMENT_3D('',#31406,#31407,#31408); +#31406 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,38.5)); +#31407 = DIRECTION('',(-1.,7.105427357611E-14,4.484155085839E-44)); +#31408 = DIRECTION('',(-7.105427357611E-14,-1.,1.980689724944E-15)); +#31409 = DEFINITIONAL_REPRESENTATION('',(#31410),#31414); +#31410 = LINE('',#31411,#31412); +#31411 = CARTESIAN_POINT('',(0.,0.)); +#31412 = VECTOR('',#31413,1.); +#31413 = DIRECTION('',(1.,0.)); +#31414 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31415 = ORIENTED_EDGE('',*,*,#31416,.F.); +#31416 = EDGE_CURVE('',#31417,#31389,#31419,.T.); +#31417 = VERTEX_POINT('',#31418); +#31418 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,38.5)); +#31419 = SURFACE_CURVE('',#31420,(#31424,#31431),.PCURVE_S1.); +#31420 = LINE('',#31421,#31422); +#31421 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,38.5)); +#31422 = VECTOR('',#31423,1.); +#31423 = DIRECTION('',(1.,-6.98108237868E-13,-3.822910400307E-29)); +#31424 = PCURVE('',#30240,#31425); +#31425 = DEFINITIONAL_REPRESENTATION('',(#31426),#31430); +#31426 = LINE('',#31427,#31428); +#31427 = CARTESIAN_POINT('',(33.000000000051,-41.59999999974)); +#31428 = VECTOR('',#31429,1.); +#31429 = DIRECTION('',(-1.,6.98108237868E-13)); +#31430 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31431 = PCURVE('',#31432,#31437); +#31432 = PLANE('',#31433); +#31433 = AXIS2_PLACEMENT_3D('',#31434,#31435,#31436); +#31434 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,38.5)); +#31435 = DIRECTION('',(-6.98108237868E-13,-1.,3.130425605302E-56)); +#31436 = DIRECTION('',(1.,-6.98108237868E-13,-3.822910400307E-29)); +#31437 = DEFINITIONAL_REPRESENTATION('',(#31438),#31442); +#31438 = LINE('',#31439,#31440); +#31439 = CARTESIAN_POINT('',(0.,0.)); +#31440 = VECTOR('',#31441,1.); +#31441 = DIRECTION('',(1.,0.)); +#31442 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31443 = ORIENTED_EDGE('',*,*,#31444,.F.); +#31444 = EDGE_CURVE('',#31445,#31417,#31447,.T.); +#31445 = VERTEX_POINT('',#31446); +#31446 = CARTESIAN_POINT('',(-34.99999999988,58.600008269745,38.5)); +#31447 = SURFACE_CURVE('',#31448,(#31452,#31459),.PCURVE_S1.); +#31448 = LINE('',#31449,#31450); +#31449 = CARTESIAN_POINT('',(-34.99999999985,61.600008269706,38.5)); +#31450 = VECTOR('',#31451,1.); +#31451 = DIRECTION('',(-9.703571279827E-12,-1.,1.980689724944E-15)); +#31452 = PCURVE('',#30240,#31453); +#31453 = DEFINITIONAL_REPRESENTATION('',(#31454),#31458); +#31454 = LINE('',#31455,#31456); +#31455 = CARTESIAN_POINT('',(32.999999999857,-61.59999999975)); +#31456 = VECTOR('',#31457,1.); +#31457 = DIRECTION('',(9.703571279827E-12,1.)); +#31458 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31459 = PCURVE('',#31460,#31465); +#31460 = PLANE('',#31461); +#31461 = AXIS2_PLACEMENT_3D('',#31462,#31463,#31464); +#31462 = CARTESIAN_POINT('',(-34.99999999988,58.600008269745,38.5)); +#31463 = DIRECTION('',(-1.,9.703571279827E-12,4.484155085839E-44)); +#31464 = DIRECTION('',(-9.703571279827E-12,-1.,1.980689724944E-15)); +#31465 = DEFINITIONAL_REPRESENTATION('',(#31466),#31470); +#31466 = LINE('',#31467,#31468); +#31467 = CARTESIAN_POINT('',(-2.999999999961,5.942069174756E-15)); +#31468 = VECTOR('',#31469,1.); +#31469 = DIRECTION('',(1.,0.)); +#31470 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31471 = ORIENTED_EDGE('',*,*,#31472,.T.); +#31472 = EDGE_CURVE('',#31445,#31473,#31475,.T.); +#31473 = VERTEX_POINT('',#31474); +#31474 = CARTESIAN_POINT('',(-35.30000000004,58.600008269745,38.5)); +#31475 = SURFACE_CURVE('',#31476,(#31480,#31487),.PCURVE_S1.); +#31476 = LINE('',#31477,#31478); +#31477 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,38.5)); +#31478 = VECTOR('',#31479,1.); +#31479 = DIRECTION('',(-1.,3.552713678801E-14,1.350596682854E-27)); +#31480 = PCURVE('',#30240,#31481); +#31481 = DEFINITIONAL_REPRESENTATION('',(#31482),#31486); +#31482 = LINE('',#31483,#31484); +#31483 = CARTESIAN_POINT('',(33.299999999972,-58.59999999979)); +#31484 = VECTOR('',#31485,1.); +#31485 = DIRECTION('',(1.,-3.552713678801E-14)); +#31486 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31487 = PCURVE('',#31488,#31493); +#31488 = PLANE('',#31489); +#31489 = AXIS2_PLACEMENT_3D('',#31490,#31491,#31492); +#31490 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,38.5)); +#31491 = DIRECTION('',(3.595697235398E-72,-1.,-7.171696191935E-87)); +#31492 = DIRECTION('',(1.,3.595697235398E-72,-1.420964917647E-27)); +#31493 = DEFINITIONAL_REPRESENTATION('',(#31494),#31498); +#31494 = LINE('',#31495,#31496); +#31495 = CARTESIAN_POINT('',(0.,0.)); +#31496 = VECTOR('',#31497,1.); +#31497 = DIRECTION('',(-1.,-7.036823479269E-29)); +#31498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31499 = ORIENTED_EDGE('',*,*,#31500,.F.); +#31500 = EDGE_CURVE('',#31501,#31473,#31503,.T.); +#31501 = VERTEX_POINT('',#31502); +#31502 = CARTESIAN_POINT('',(-36.80000000004,60.100008269669,38.5)); +#31503 = SURFACE_CURVE('',#31504,(#31509,#31516),.PCURVE_S1.); +#31504 = CIRCLE('',#31505,1.5); +#31505 = AXIS2_PLACEMENT_3D('',#31506,#31507,#31508); +#31506 = CARTESIAN_POINT('',(-35.30000000004,60.100008269745,38.5)); +#31507 = DIRECTION('',(1.420970823333E-27,1.980689724944E-15,1.)); +#31508 = DIRECTION('',(-0.707106781169,-0.707106781204, + 1.400559135971E-15)); +#31509 = PCURVE('',#30240,#31510); +#31510 = DEFINITIONAL_REPRESENTATION('',(#31511),#31515); +#31511 = CIRCLE('',#31512,1.5); +#31512 = AXIS2_PLACEMENT_2D('',#31513,#31514); +#31513 = CARTESIAN_POINT('',(33.300000000047,-60.09999999979)); +#31514 = DIRECTION('',(0.707106781169,0.707106781204)); +#31515 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31516 = PCURVE('',#31517,#31522); +#31517 = CYLINDRICAL_SURFACE('',#31518,1.5); +#31518 = AXIS2_PLACEMENT_3D('',#31519,#31520,#31521); +#31519 = CARTESIAN_POINT('',(-35.30000000004,60.100008269745,38.5)); +#31520 = DIRECTION('',(8.978486131298E-26,-7.171696191612E-87,1.)); +#31521 = DIRECTION('',(-0.707106781169,-0.707106781204,6.34874842807E-26 + )); +#31522 = DEFINITIONAL_REPRESENTATION('',(#31523),#31527); +#31523 = LINE('',#31524,#31525); +#31524 = CARTESIAN_POINT('',(-6.28318530718,1.06581410364E-13)); +#31525 = VECTOR('',#31526,1.); +#31526 = DIRECTION('',(1.,0.)); +#31527 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31528 = ORIENTED_EDGE('',*,*,#31529,.F.); +#31529 = EDGE_CURVE('',#31530,#31501,#31532,.T.); +#31530 = VERTEX_POINT('',#31531); +#31531 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,38.5)); +#31532 = SURFACE_CURVE('',#31533,(#31537,#31544),.PCURVE_S1.); +#31533 = LINE('',#31534,#31535); +#31534 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,38.5)); +#31535 = VECTOR('',#31536,1.); +#31536 = DIRECTION('',(5.054438349408E-11,-1.,1.980689724944E-15)); +#31537 = PCURVE('',#30240,#31538); +#31538 = DEFINITIONAL_REPRESENTATION('',(#31539),#31543); +#31539 = LINE('',#31540,#31541); +#31540 = CARTESIAN_POINT('',(34.800000000123,-61.59999999975)); +#31541 = VECTOR('',#31542,1.); +#31542 = DIRECTION('',(-5.054438349408E-11,1.)); +#31543 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31544 = PCURVE('',#31545,#31550); +#31545 = PLANE('',#31546); +#31546 = AXIS2_PLACEMENT_3D('',#31547,#31548,#31549); +#31547 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,38.5)); +#31548 = DIRECTION('',(-1.,-5.054438349408E-11,8.978486131298E-26)); +#31549 = DIRECTION('',(5.054438349408E-11,-1.,1.980689724944E-15)); +#31550 = DEFINITIONAL_REPRESENTATION('',(#31551),#31555); +#31551 = LINE('',#31552,#31553); +#31552 = CARTESIAN_POINT('',(0.,0.)); +#31553 = VECTOR('',#31554,1.); +#31554 = DIRECTION('',(1.,0.)); +#31555 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31556 = ORIENTED_EDGE('',*,*,#31557,.F.); +#31557 = EDGE_CURVE('',#31558,#31530,#31560,.T.); +#31558 = VERTEX_POINT('',#31559); +#31559 = CARTESIAN_POINT('',(-29.99999999995,68.400008269933,38.5)); +#31560 = SURFACE_CURVE('',#31561,(#31566,#31573),.PCURVE_S1.); +#31561 = CIRCLE('',#31562,6.800000000227); +#31562 = AXIS2_PLACEMENT_3D('',#31563,#31564,#31565); +#31563 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,38.5)); +#31564 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#31565 = DIRECTION('',(-1.832521062938E-12,1.,-1.980689724944E-15)); +#31566 = PCURVE('',#30240,#31567); +#31567 = DEFINITIONAL_REPRESENTATION('',(#31568),#31572); +#31568 = CIRCLE('',#31569,6.800000000227); +#31569 = AXIS2_PLACEMENT_2D('',#31570,#31571); +#31570 = CARTESIAN_POINT('',(27.999999999943,-61.59999999975)); +#31571 = DIRECTION('',(1.832521062938E-12,-1.)); +#31572 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31573 = PCURVE('',#31574,#31579); +#31574 = CYLINDRICAL_SURFACE('',#31575,6.800000000227); +#31575 = AXIS2_PLACEMENT_3D('',#31576,#31577,#31578); +#31576 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,38.5)); +#31577 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#31578 = DIRECTION('',(-1.832521062938E-12,1.,-1.7763568394E-15)); +#31579 = DEFINITIONAL_REPRESENTATION('',(#31580),#31584); +#31580 = LINE('',#31581,#31582); +#31581 = CARTESIAN_POINT('',(0.,0.)); +#31582 = VECTOR('',#31583,1.); +#31583 = DIRECTION('',(1.,0.)); +#31584 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31585 = ORIENTED_EDGE('',*,*,#31586,.F.); +#31586 = EDGE_CURVE('',#31587,#31558,#31589,.T.); +#31587 = VERTEX_POINT('',#31588); +#31588 = CARTESIAN_POINT('',(-28.49999999977,68.400008269883,38.5)); +#31589 = SURFACE_CURVE('',#31590,(#31594,#31601),.PCURVE_S1.); +#31590 = LINE('',#31591,#31592); +#31591 = CARTESIAN_POINT('',(-26.99999999982,68.400008269833,38.5)); +#31592 = VECTOR('',#31593,1.); +#31593 = DIRECTION('',(-1.,3.324451824797E-11,-6.442611078683E-26)); +#31594 = PCURVE('',#30240,#31595); +#31595 = DEFINITIONAL_REPRESENTATION('',(#31596),#31600); +#31596 = LINE('',#31597,#31598); +#31597 = CARTESIAN_POINT('',(24.999999999829,-68.39999999988)); +#31598 = VECTOR('',#31599,1.); +#31599 = DIRECTION('',(1.,-3.324451824797E-11)); +#31600 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31601 = PCURVE('',#31602,#31607); +#31602 = PLANE('',#31603); +#31603 = AXIS2_PLACEMENT_3D('',#31604,#31605,#31606); +#31604 = CARTESIAN_POINT('',(-26.99999999982,68.400008269833,38.5)); +#31605 = DIRECTION('',(3.324451824797E-11,1.,-1.7763568394E-15)); +#31606 = DIRECTION('',(-1.,3.324451824797E-11,-6.442611078683E-26)); +#31607 = DEFINITIONAL_REPRESENTATION('',(#31608),#31612); +#31608 = LINE('',#31609,#31610); +#31609 = CARTESIAN_POINT('',(0.,0.)); +#31610 = VECTOR('',#31611,1.); +#31611 = DIRECTION('',(1.,0.)); +#31612 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31613 = ORIENTED_EDGE('',*,*,#31614,.F.); +#31614 = EDGE_CURVE('',#31615,#31587,#31617,.T.); +#31615 = VERTEX_POINT('',#31616); +#31616 = CARTESIAN_POINT('',(-26.99999999982,66.900008269886,38.5)); +#31617 = SURFACE_CURVE('',#31618,(#31623,#31630),.PCURVE_S1.); +#31618 = CIRCLE('',#31619,1.5); +#31619 = AXIS2_PLACEMENT_3D('',#31620,#31621,#31622); +#31620 = CARTESIAN_POINT('',(-28.49999999982,66.900008269883,38.5)); +#31621 = DIRECTION('',(1.421157955021E-27,1.980689724944E-15,1.)); +#31622 = DIRECTION('',(0.707106781198,0.707106781175,-1.400559135914E-15 + )); +#31623 = PCURVE('',#30240,#31624); +#31624 = DEFINITIONAL_REPRESENTATION('',(#31625),#31629); +#31625 = CIRCLE('',#31626,1.5); +#31626 = AXIS2_PLACEMENT_2D('',#31627,#31628); +#31627 = CARTESIAN_POINT('',(26.499999999826,-66.89999999993)); +#31628 = DIRECTION('',(-0.707106781198,-0.707106781175)); +#31629 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31630 = PCURVE('',#31631,#31636); +#31631 = CYLINDRICAL_SURFACE('',#31632,1.5); +#31632 = AXIS2_PLACEMENT_3D('',#31633,#31634,#31635); +#31633 = CARTESIAN_POINT('',(-28.49999999982,66.900008269883,38.5)); +#31634 = DIRECTION('',(-3.181738981772E-27,1.7763568394E-15,1.)); +#31635 = DIRECTION('',(0.707106781198,0.707106781175,-1.256073966925E-15 + )); +#31636 = DEFINITIONAL_REPRESENTATION('',(#31637),#31641); +#31637 = LINE('',#31638,#31639); +#31638 = CARTESIAN_POINT('',(-2.6645352591E-15,0.)); +#31639 = VECTOR('',#31640,1.); +#31640 = DIRECTION('',(1.,0.)); +#31641 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31642 = ORIENTED_EDGE('',*,*,#31643,.F.); +#31643 = EDGE_CURVE('',#31644,#31615,#31646,.T.); +#31644 = VERTEX_POINT('',#31645); +#31645 = CARTESIAN_POINT('',(-26.99999999982,66.600008269598,38.5)); +#31646 = SURFACE_CURVE('',#31647,(#31651,#31658),.PCURVE_S1.); +#31647 = LINE('',#31648,#31649); +#31648 = CARTESIAN_POINT('',(-26.99999999982,66.600008269586,38.5)); +#31649 = VECTOR('',#31650,1.); +#31650 = DIRECTION('',(-1.791159811587E-12,1.,-1.980689724944E-15)); +#31651 = PCURVE('',#30240,#31652); +#31652 = DEFINITIONAL_REPRESENTATION('',(#31653),#31657); +#31653 = LINE('',#31654,#31655); +#31654 = CARTESIAN_POINT('',(24.999999999825,-66.59999999963)); +#31655 = VECTOR('',#31656,1.); +#31656 = DIRECTION('',(1.791159811587E-12,-1.)); +#31657 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31658 = PCURVE('',#31659,#31664); +#31659 = PLANE('',#31660); +#31660 = AXIS2_PLACEMENT_3D('',#31661,#31662,#31663); +#31661 = CARTESIAN_POINT('',(-26.99999999982,66.600008269598,38.5)); +#31662 = DIRECTION('',(1.,1.791159811587E-12,-4.484155085839E-44)); +#31663 = DIRECTION('',(-1.791159811587E-12,1.,-1.980689724944E-15)); +#31664 = DEFINITIONAL_REPRESENTATION('',(#31665),#31669); +#31665 = LINE('',#31666,#31667); +#31666 = CARTESIAN_POINT('',(-1.179500941362E-11,-2.336225395117E-26)); +#31667 = VECTOR('',#31668,1.); +#31668 = DIRECTION('',(1.,0.)); +#31669 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31670 = ORIENTED_EDGE('',*,*,#31671,.F.); +#31671 = EDGE_CURVE('',#31672,#31644,#31674,.T.); +#31672 = VERTEX_POINT('',#31673); +#31673 = CARTESIAN_POINT('',(23.000000000186,66.600008269742,38.5)); +#31674 = SURFACE_CURVE('',#31675,(#31679,#31686),.PCURVE_S1.); +#31675 = LINE('',#31676,#31677); +#31676 = CARTESIAN_POINT('',(26.000000000131,66.60000826975,38.5)); +#31677 = VECTOR('',#31678,1.); +#31678 = DIRECTION('',(-1.,-2.870402328519E-12,7.106354245054E-27)); +#31679 = PCURVE('',#30240,#31680); +#31680 = DEFINITIONAL_REPRESENTATION('',(#31681),#31685); +#31681 = LINE('',#31682,#31683); +#31682 = CARTESIAN_POINT('',(-28.00000000013,-66.59999999979)); +#31683 = VECTOR('',#31684,1.); +#31684 = DIRECTION('',(1.,2.870402328519E-12)); +#31685 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31686 = PCURVE('',#31687,#31692); +#31687 = PLANE('',#31688); +#31688 = AXIS2_PLACEMENT_3D('',#31689,#31690,#31691); +#31689 = CARTESIAN_POINT('',(23.000000000186,66.600008269742,38.5)); +#31690 = DIRECTION('',(-2.870402328519E-12,1.,1.287132919983E-55)); +#31691 = DIRECTION('',(-1.,-2.870402328519E-12,7.106354245054E-27)); +#31692 = DEFINITIONAL_REPRESENTATION('',(#31693),#31697); +#31693 = LINE('',#31694,#31695); +#31694 = CARTESIAN_POINT('',(-2.999999999945,2.131906273477E-26)); +#31695 = VECTOR('',#31696,1.); +#31696 = DIRECTION('',(1.,0.)); +#31697 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31698 = ORIENTED_EDGE('',*,*,#31699,.F.); +#31699 = EDGE_CURVE('',#31700,#31672,#31702,.T.); +#31700 = VERTEX_POINT('',#31701); +#31701 = CARTESIAN_POINT('',(23.000000000186,66.900008269824,38.5)); +#31702 = SURFACE_CURVE('',#31703,(#31707,#31714),.PCURVE_S1.); +#31703 = LINE('',#31704,#31705); +#31704 = CARTESIAN_POINT('',(23.000000000186,68.400008270055,38.5)); +#31705 = VECTOR('',#31706,1.); +#31706 = DIRECTION('',(2.960594732123E-14,-1.,1.980689724944E-15)); +#31707 = PCURVE('',#30240,#31708); +#31708 = DEFINITIONAL_REPRESENTATION('',(#31709),#31713); +#31709 = LINE('',#31710,#31711); +#31710 = CARTESIAN_POINT('',(-25.00000000018,-68.4000000001)); +#31711 = VECTOR('',#31712,1.); +#31712 = DIRECTION('',(-2.960594732123E-14,1.)); +#31713 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31714 = PCURVE('',#31715,#31720); +#31715 = PLANE('',#31716); +#31716 = AXIS2_PLACEMENT_3D('',#31717,#31718,#31719); +#31717 = CARTESIAN_POINT('',(23.000000000186,66.900008269948,38.5)); +#31718 = DIRECTION('',(-1.,-2.960594730768E-14,4.484155085839E-44)); +#31719 = DIRECTION('',(2.960594730768E-14,-1.,1.980689724944E-15)); +#31720 = DEFINITIONAL_REPRESENTATION('',(#31721),#31725); +#31721 = LINE('',#31722,#31723); +#31722 = CARTESIAN_POINT('',(-1.500000000107,2.971034587628E-15)); +#31723 = VECTOR('',#31724,1.); +#31724 = DIRECTION('',(1.,0.)); +#31725 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31726 = ORIENTED_EDGE('',*,*,#31727,.F.); +#31727 = EDGE_CURVE('',#31728,#31700,#31730,.T.); +#31728 = VERTEX_POINT('',#31729); +#31729 = CARTESIAN_POINT('',(24.500000000311,68.400008269824,38.5)); +#31730 = SURFACE_CURVE('',#31731,(#31736,#31743),.PCURVE_S1.); +#31731 = CIRCLE('',#31732,1.5); +#31732 = AXIS2_PLACEMENT_3D('',#31733,#31734,#31735); +#31733 = CARTESIAN_POINT('',(24.500000000186,66.900008269824,38.5)); +#31734 = DIRECTION('',(1.420980985805E-27,1.980689724944E-15,1.)); +#31735 = DIRECTION('',(-0.707106781157,0.707106781216, + -1.400559135992E-15)); +#31736 = PCURVE('',#30240,#31737); +#31737 = DEFINITIONAL_REPRESENTATION('',(#31738),#31742); +#31738 = CIRCLE('',#31739,1.5); +#31739 = AXIS2_PLACEMENT_2D('',#31740,#31741); +#31740 = CARTESIAN_POINT('',(-26.50000000018,-66.89999999987)); +#31741 = DIRECTION('',(0.707106781157,-0.707106781216)); +#31742 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31743 = PCURVE('',#30464,#31744); +#31744 = DEFINITIONAL_REPRESENTATION('',(#31745),#31749); +#31745 = LINE('',#31746,#31747); +#31746 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#31747 = VECTOR('',#31748,1.); +#31748 = DIRECTION('',(1.,0.)); +#31749 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31750 = ORIENTED_EDGE('',*,*,#31751,.F.); +#31751 = EDGE_CURVE('',#31752,#31728,#31754,.T.); +#31752 = VERTEX_POINT('',#31753); +#31753 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,38.5)); +#31754 = SURFACE_CURVE('',#31755,(#31759,#31766),.PCURVE_S1.); +#31755 = LINE('',#31756,#31757); +#31756 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,38.5)); +#31757 = VECTOR('',#31758,1.); +#31758 = DIRECTION('',(-1.,8.318041361553E-11,-1.633336256472E-25)); +#31759 = PCURVE('',#30240,#31760); +#31760 = DEFINITIONAL_REPRESENTATION('',(#31761),#31765); +#31761 = LINE('',#31762,#31763); +#31762 = CARTESIAN_POINT('',(-28.00001644579,-68.39999999974)); +#31763 = VECTOR('',#31764,1.); +#31764 = DIRECTION('',(1.,-8.318041361553E-11)); +#31765 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31766 = PCURVE('',#30431,#31767); +#31767 = DEFINITIONAL_REPRESENTATION('',(#31768),#31772); +#31768 = LINE('',#31769,#31770); +#31769 = CARTESIAN_POINT('',(0.,0.)); +#31770 = VECTOR('',#31771,1.); +#31771 = DIRECTION('',(1.,0.)); +#31772 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31773 = ORIENTED_EDGE('',*,*,#31774,.F.); +#31774 = EDGE_CURVE('',#31775,#31752,#31777,.T.); +#31775 = VERTEX_POINT('',#31776); +#31776 = CARTESIAN_POINT('',(32.800000000164,61.600008269707,38.5)); +#31777 = SURFACE_CURVE('',#31778,(#31783,#31790),.PCURVE_S1.); +#31778 = CIRCLE('',#31779,6.800000000012); +#31779 = AXIS2_PLACEMENT_3D('',#31780,#31781,#31782); +#31780 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,38.5)); +#31781 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#31782 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#31783 = PCURVE('',#30240,#31784); +#31784 = DEFINITIONAL_REPRESENTATION('',(#31785),#31789); +#31785 = CIRCLE('',#31786,6.800000000012); +#31786 = AXIS2_PLACEMENT_2D('',#31787,#31788); +#31787 = CARTESIAN_POINT('',(-28.00000000015,-61.59999999975)); +#31788 = DIRECTION('',(-1.,-8.723744686338E-59)); +#31789 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31790 = PCURVE('',#30403,#31791); +#31791 = DEFINITIONAL_REPRESENTATION('',(#31792),#31796); +#31792 = LINE('',#31793,#31794); +#31793 = CARTESIAN_POINT('',(0.,0.)); +#31794 = VECTOR('',#31795,1.); +#31795 = DIRECTION('',(1.,0.)); +#31796 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31797 = ORIENTED_EDGE('',*,*,#31798,.F.); +#31798 = EDGE_CURVE('',#30224,#31775,#31799,.T.); +#31799 = SURFACE_CURVE('',#31800,(#31804,#31811),.PCURVE_S1.); +#31800 = LINE('',#31801,#31802); +#31801 = CARTESIAN_POINT('',(32.800000000164,58.600008269699,38.5)); +#31802 = VECTOR('',#31803,1.); +#31803 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#31804 = PCURVE('',#30240,#31805); +#31805 = DEFINITIONAL_REPRESENTATION('',(#31806),#31810); +#31806 = LINE('',#31807,#31808); +#31807 = CARTESIAN_POINT('',(-34.80000000016,-58.59999999974)); +#31808 = VECTOR('',#31809,1.); +#31809 = DIRECTION('',(-4.866513180261E-57,-1.)); +#31810 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31811 = PCURVE('',#30266,#31812); +#31812 = DEFINITIONAL_REPRESENTATION('',(#31813),#31817); +#31813 = LINE('',#31814,#31815); +#31814 = CARTESIAN_POINT('',(0.,0.)); +#31815 = VECTOR('',#31816,1.); +#31816 = DIRECTION('',(1.,0.)); +#31817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31818 = FACE_BOUND('',#31819,.T.); +#31819 = EDGE_LOOP('',(#31820,#31850,#31878,#31906)); +#31820 = ORIENTED_EDGE('',*,*,#31821,.F.); +#31821 = EDGE_CURVE('',#31822,#31824,#31826,.T.); +#31822 = VERTEX_POINT('',#31823); +#31823 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,38.5)); +#31824 = VERTEX_POINT('',#31825); +#31825 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,38.5)); +#31826 = SURFACE_CURVE('',#31827,(#31831,#31838),.PCURVE_S1.); +#31827 = LINE('',#31828,#31829); +#31828 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,38.5)); +#31829 = VECTOR('',#31830,1.); +#31830 = DIRECTION('',(2.81449061189E-42,-1.,1.980689724944E-15)); +#31831 = PCURVE('',#30240,#31832); +#31832 = DEFINITIONAL_REPRESENTATION('',(#31833),#31837); +#31833 = LINE('',#31834,#31835); +#31834 = CARTESIAN_POINT('',(-25.30000000015,-62.09999999973)); +#31835 = VECTOR('',#31836,1.); +#31836 = DIRECTION('',(4.866513180261E-57,1.)); +#31837 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31838 = PCURVE('',#31839,#31844); +#31839 = PLANE('',#31840); +#31840 = AXIS2_PLACEMENT_3D('',#31841,#31842,#31843); +#31841 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,38.5)); +#31842 = DIRECTION('',(-1.,-2.81449061189E-42,4.484155085839E-44)); +#31843 = DIRECTION('',(2.81449061189E-42,-1.,1.980689724944E-15)); +#31844 = DEFINITIONAL_REPRESENTATION('',(#31845),#31849); +#31845 = LINE('',#31846,#31847); +#31846 = CARTESIAN_POINT('',(0.,0.)); +#31847 = VECTOR('',#31848,1.); +#31848 = DIRECTION('',(1.,0.)); +#31849 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31850 = ORIENTED_EDGE('',*,*,#31851,.F.); +#31851 = EDGE_CURVE('',#31852,#31822,#31854,.T.); +#31852 = VERTEX_POINT('',#31853); +#31853 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,38.5)); +#31854 = SURFACE_CURVE('',#31855,(#31859,#31866),.PCURVE_S1.); +#31855 = LINE('',#31856,#31857); +#31856 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,38.5)); +#31857 = VECTOR('',#31858,1.); +#31858 = DIRECTION('',(1.,-5.469078939036E-14,-1.312639433053E-27)); +#31859 = PCURVE('',#30240,#31860); +#31860 = DEFINITIONAL_REPRESENTATION('',(#31861),#31865); +#31861 = LINE('',#31862,#31863); +#31862 = CARTESIAN_POINT('',(15.299999999872,-62.09999999973)); +#31863 = VECTOR('',#31864,1.); +#31864 = DIRECTION('',(-1.,5.469078939036E-14)); +#31865 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31866 = PCURVE('',#31867,#31872); +#31867 = PLANE('',#31868); +#31868 = AXIS2_PLACEMENT_3D('',#31869,#31870,#31871); +#31869 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,38.5)); +#31870 = DIRECTION('',(-5.469078939036E-14,-1.,2.452419813934E-57)); +#31871 = DIRECTION('',(1.,-5.469078939036E-14,-1.312639433053E-27)); +#31872 = DEFINITIONAL_REPRESENTATION('',(#31873),#31877); +#31873 = LINE('',#31874,#31875); +#31874 = CARTESIAN_POINT('',(0.,0.)); +#31875 = VECTOR('',#31876,1.); +#31876 = DIRECTION('',(1.,0.)); +#31877 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31878 = ORIENTED_EDGE('',*,*,#31879,.F.); +#31879 = EDGE_CURVE('',#31880,#31852,#31882,.T.); +#31880 = VERTEX_POINT('',#31881); +#31881 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,38.5)); +#31882 = SURFACE_CURVE('',#31883,(#31887,#31894),.PCURVE_S1.); +#31883 = LINE('',#31884,#31885); +#31884 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,38.5)); +#31885 = VECTOR('',#31886,1.); +#31886 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#31887 = PCURVE('',#30240,#31888); +#31888 = DEFINITIONAL_REPRESENTATION('',(#31889),#31893); +#31889 = LINE('',#31890,#31891); +#31890 = CARTESIAN_POINT('',(15.299999999872,-33.59999999976)); +#31891 = VECTOR('',#31892,1.); +#31892 = DIRECTION('',(-4.866513180261E-57,-1.)); +#31893 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31894 = PCURVE('',#31895,#31900); +#31895 = PLANE('',#31896); +#31896 = AXIS2_PLACEMENT_3D('',#31897,#31898,#31899); +#31897 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,38.5)); +#31898 = DIRECTION('',(1.,2.81449061189E-42,-4.484155085839E-44)); +#31899 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#31900 = DEFINITIONAL_REPRESENTATION('',(#31901),#31905); +#31901 = LINE('',#31902,#31903); +#31902 = CARTESIAN_POINT('',(0.,0.)); +#31903 = VECTOR('',#31904,1.); +#31904 = DIRECTION('',(1.,0.)); +#31905 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31906 = ORIENTED_EDGE('',*,*,#31907,.F.); +#31907 = EDGE_CURVE('',#31824,#31880,#31908,.T.); +#31908 = SURFACE_CURVE('',#31909,(#31913,#31920),.PCURVE_S1.); +#31909 = LINE('',#31910,#31911); +#31910 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,38.5)); +#31911 = VECTOR('',#31912,1.); +#31912 = DIRECTION('',(-1.,5.523769728426E-14,1.311556178207E-27)); +#31913 = PCURVE('',#30240,#31914); +#31914 = DEFINITIONAL_REPRESENTATION('',(#31915),#31919); +#31915 = LINE('',#31916,#31917); +#31916 = CARTESIAN_POINT('',(-25.30000000015,-33.59999999976)); +#31917 = VECTOR('',#31918,1.); +#31918 = DIRECTION('',(1.,-5.523769728426E-14)); +#31919 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31920 = PCURVE('',#31921,#31926); +#31921 = PLANE('',#31922); +#31922 = AXIS2_PLACEMENT_3D('',#31923,#31924,#31925); +#31923 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,38.5)); +#31924 = DIRECTION('',(5.523769728426E-14,1.,-2.476944012073E-57)); +#31925 = DIRECTION('',(-1.,5.523769728426E-14,1.311556178207E-27)); +#31926 = DEFINITIONAL_REPRESENTATION('',(#31927),#31931); +#31927 = LINE('',#31928,#31929); +#31928 = CARTESIAN_POINT('',(0.,0.)); +#31929 = VECTOR('',#31930,1.); +#31930 = DIRECTION('',(1.,1.793662034336E-43)); +#31931 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31932 = FACE_BOUND('',#31933,.T.); +#31933 = EDGE_LOOP('',(#31934)); +#31934 = ORIENTED_EDGE('',*,*,#31935,.T.); +#31935 = EDGE_CURVE('',#31936,#31936,#31938,.T.); +#31936 = VERTEX_POINT('',#31937); +#31937 = CARTESIAN_POINT('',(27.050000000063,-61.5999917304,38.5)); +#31938 = SURFACE_CURVE('',#31939,(#31944,#31951),.PCURVE_S1.); +#31939 = CIRCLE('',#31940,1.05); +#31940 = AXIS2_PLACEMENT_3D('',#31941,#31942,#31943); +#31941 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,38.5)); +#31942 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#31943 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#31944 = PCURVE('',#30240,#31945); +#31945 = DEFINITIONAL_REPRESENTATION('',(#31946),#31950); +#31946 = CIRCLE('',#31947,1.05); +#31947 = AXIS2_PLACEMENT_2D('',#31948,#31949); +#31948 = CARTESIAN_POINT('',(-28.00000000006,61.60000000036)); +#31949 = DIRECTION('',(1.,-2.313809353631E-58)); +#31950 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31951 = PCURVE('',#31952,#31957); +#31952 = CYLINDRICAL_SURFACE('',#31953,1.05); +#31953 = AXIS2_PLACEMENT_3D('',#31954,#31955,#31956); +#31954 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,38.5)); +#31955 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#31956 = DIRECTION('',(-1.,1.776343980716E-58,4.484155085839E-44)); +#31957 = DEFINITIONAL_REPRESENTATION('',(#31958),#31962); +#31958 = LINE('',#31959,#31960); +#31959 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#31960 = VECTOR('',#31961,1.); +#31961 = DIRECTION('',(1.,0.)); +#31962 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31963 = FACE_BOUND('',#31964,.T.); +#31964 = EDGE_LOOP('',(#31965)); +#31965 = ORIENTED_EDGE('',*,*,#31966,.T.); +#31966 = EDGE_CURVE('',#31967,#31967,#31969,.T.); +#31967 = VERTEX_POINT('',#31968); +#31968 = CARTESIAN_POINT('',(-28.95000000003,-61.59999173032,38.5)); +#31969 = SURFACE_CURVE('',#31970,(#31975,#31982),.PCURVE_S1.); +#31970 = CIRCLE('',#31971,1.05); +#31971 = AXIS2_PLACEMENT_3D('',#31972,#31973,#31974); +#31972 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,38.5)); +#31973 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#31974 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#31975 = PCURVE('',#30240,#31976); +#31976 = DEFINITIONAL_REPRESENTATION('',(#31977),#31981); +#31977 = CIRCLE('',#31978,1.05); +#31978 = AXIS2_PLACEMENT_2D('',#31979,#31980); +#31979 = CARTESIAN_POINT('',(28.000000000031,61.60000000028)); +#31980 = DIRECTION('',(1.,8.723744686338E-59)); +#31981 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31982 = PCURVE('',#31983,#31988); +#31983 = CYLINDRICAL_SURFACE('',#31984,1.05); +#31984 = AXIS2_PLACEMENT_3D('',#31985,#31986,#31987); +#31985 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,38.5)); +#31986 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#31987 = DIRECTION('',(-1.,-3.215899795316E-130,4.484155085839E-44)); +#31988 = DEFINITIONAL_REPRESENTATION('',(#31989),#31993); +#31989 = LINE('',#31990,#31991); +#31990 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#31991 = VECTOR('',#31992,1.); +#31992 = DIRECTION('',(1.,0.)); +#31993 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#31994 = FACE_BOUND('',#31995,.T.); +#31995 = EDGE_LOOP('',(#31996)); +#31996 = ORIENTED_EDGE('',*,*,#31997,.T.); +#31997 = EDGE_CURVE('',#31998,#31998,#32000,.T.); +#31998 = VERTEX_POINT('',#31999); +#31999 = CARTESIAN_POINT('',(27.050000000152,61.600008269707,38.5)); +#32000 = SURFACE_CURVE('',#32001,(#32006,#32013),.PCURVE_S1.); +#32001 = CIRCLE('',#32002,1.05); +#32002 = AXIS2_PLACEMENT_3D('',#32003,#32004,#32005); +#32003 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,38.5)); +#32004 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#32005 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#32006 = PCURVE('',#30240,#32007); +#32007 = DEFINITIONAL_REPRESENTATION('',(#32008),#32012); +#32008 = CIRCLE('',#32009,1.05); +#32009 = AXIS2_PLACEMENT_2D('',#32010,#32011); +#32010 = CARTESIAN_POINT('',(-28.00000000015,-61.59999999975)); +#32011 = DIRECTION('',(1.,-2.313809353631E-58)); +#32012 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32013 = PCURVE('',#32014,#32019); +#32014 = CYLINDRICAL_SURFACE('',#32015,1.05); +#32015 = AXIS2_PLACEMENT_3D('',#32016,#32017,#32018); +#32016 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,38.5)); +#32017 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#32018 = DIRECTION('',(-1.,1.776343980716E-58,4.484155085839E-44)); +#32019 = DEFINITIONAL_REPRESENTATION('',(#32020),#32024); +#32020 = LINE('',#32021,#32022); +#32021 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#32022 = VECTOR('',#32023,1.); +#32023 = DIRECTION('',(1.,0.)); +#32024 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32025 = FACE_BOUND('',#32026,.T.); +#32026 = EDGE_LOOP('',(#32027)); +#32027 = ORIENTED_EDGE('',*,*,#32028,.T.); +#32028 = EDGE_CURVE('',#32029,#32029,#32031,.T.); +#32029 = VERTEX_POINT('',#32030); +#32030 = CARTESIAN_POINT('',(-28.94999999994,61.600008269706,38.5)); +#32031 = SURFACE_CURVE('',#32032,(#32037,#32044),.PCURVE_S1.); +#32032 = CIRCLE('',#32033,1.05); +#32033 = AXIS2_PLACEMENT_3D('',#32034,#32035,#32036); +#32034 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,38.5)); +#32035 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#32036 = DIRECTION('',(-1.,-6.37236764453E-58,1.420964917647E-27)); +#32037 = PCURVE('',#30240,#32038); +#32038 = DEFINITIONAL_REPRESENTATION('',(#32039),#32043); +#32039 = CIRCLE('',#32040,1.05); +#32040 = AXIS2_PLACEMENT_2D('',#32041,#32042); +#32041 = CARTESIAN_POINT('',(27.999999999943,-61.59999999975)); +#32042 = DIRECTION('',(1.,7.244742113164E-58)); +#32043 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32044 = PCURVE('',#32045,#32050); +#32045 = CYLINDRICAL_SURFACE('',#32046,1.05); +#32046 = AXIS2_PLACEMENT_3D('',#32047,#32048,#32049); +#32047 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,38.5)); +#32048 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#32049 = DIRECTION('',(-1.,-7.105375922863E-58,4.484155085839E-44)); +#32050 = DEFINITIONAL_REPRESENTATION('',(#32051),#32055); +#32051 = LINE('',#32052,#32053); +#32052 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#32053 = VECTOR('',#32054,1.); +#32054 = DIRECTION('',(1.,0.)); +#32055 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32056 = FACE_BOUND('',#32057,.T.); +#32057 = EDGE_LOOP('',(#32058)); +#32058 = ORIENTED_EDGE('',*,*,#32059,.T.); +#32059 = EDGE_CURVE('',#32060,#32060,#32062,.T.); +#32060 = VERTEX_POINT('',#32061); +#32061 = CARTESIAN_POINT('',(-16.15444504208,-33.23835181012,38.5)); +#32062 = SURFACE_CURVE('',#32063,(#32068,#32075),.PCURVE_S1.); +#32063 = CIRCLE('',#32064,1.05); +#32064 = AXIS2_PLACEMENT_3D('',#32065,#32066,#32067); +#32065 = CARTESIAN_POINT('',(-17.20444504208,-33.23835181012,38.5)); +#32066 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#32067 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#32068 = PCURVE('',#30240,#32069); +#32069 = DEFINITIONAL_REPRESENTATION('',(#32070),#32074); +#32070 = CIRCLE('',#32071,1.05); +#32071 = AXIS2_PLACEMENT_2D('',#32072,#32073); +#32072 = CARTESIAN_POINT('',(15.204445042088,33.238360080074)); +#32073 = DIRECTION('',(1.,-2.313809353631E-58)); +#32074 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32075 = PCURVE('',#32076,#32081); +#32076 = CYLINDRICAL_SURFACE('',#32077,1.05); +#32077 = AXIS2_PLACEMENT_3D('',#32078,#32079,#32080); +#32078 = CARTESIAN_POINT('',(-17.20444504208,-33.23835181012,38.5)); +#32079 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#32080 = DIRECTION('',(-1.,1.776343980716E-58,4.484155085839E-44)); +#32081 = DEFINITIONAL_REPRESENTATION('',(#32082),#32086); +#32082 = LINE('',#32083,#32084); +#32083 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#32084 = VECTOR('',#32085,1.); +#32085 = DIRECTION('',(1.,0.)); +#32086 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32087 = FACE_BOUND('',#32088,.T.); +#32088 = EDGE_LOOP('',(#32089,#32119,#32147,#32175)); +#32089 = ORIENTED_EDGE('',*,*,#32090,.T.); +#32090 = EDGE_CURVE('',#32091,#32093,#32095,.T.); +#32091 = VERTEX_POINT('',#32092); +#32092 = CARTESIAN_POINT('',(21.000000000228,-56.59999173034,38.5)); +#32093 = VERTEX_POINT('',#32094); +#32094 = CARTESIAN_POINT('',(21.000000000228,23.600008269715,38.5)); +#32095 = SURFACE_CURVE('',#32096,(#32100,#32107),.PCURVE_S1.); +#32096 = LINE('',#32097,#32098); +#32097 = CARTESIAN_POINT('',(21.000000000228,11.800008269834,38.5)); +#32098 = VECTOR('',#32099,1.); +#32099 = DIRECTION('',(1.960514351287E-30,1.,-1.980689724944E-15)); +#32100 = PCURVE('',#30240,#32101); +#32101 = DEFINITIONAL_REPRESENTATION('',(#32102),#32106); +#32102 = LINE('',#32103,#32104); +#32103 = CARTESIAN_POINT('',(-23.00000000022,-11.79999999988)); +#32104 = VECTOR('',#32105,1.); +#32105 = DIRECTION('',(-1.96051435129E-30,-1.)); +#32106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32107 = PCURVE('',#32108,#32113); +#32108 = PLANE('',#32109); +#32109 = AXIS2_PLACEMENT_3D('',#32110,#32111,#32112); +#32110 = CARTESIAN_POINT('',(21.000000000228,23.600008269715,40.)); +#32111 = DIRECTION('',(1.,-1.960514351287E-30,-4.484155085839E-44)); +#32112 = DIRECTION('',(-1.960514351287E-30,-1.,1.710690767248E-15)); +#32113 = DEFINITIONAL_REPRESENTATION('',(#32114),#32118); +#32114 = LINE('',#32115,#32116); +#32115 = CARTESIAN_POINT('',(11.799999999881,1.5)); +#32116 = VECTOR('',#32117,1.); +#32117 = DIRECTION('',(-1.,2.699989576963E-16)); +#32118 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32119 = ORIENTED_EDGE('',*,*,#32120,.T.); +#32120 = EDGE_CURVE('',#32093,#32121,#32123,.T.); +#32121 = VERTEX_POINT('',#32122); +#32122 = CARTESIAN_POINT('',(-14.99999999981,23.600008269715,38.5)); +#32123 = SURFACE_CURVE('',#32124,(#32128,#32135),.PCURVE_S1.); +#32124 = LINE('',#32125,#32126); +#32125 = CARTESIAN_POINT('',(-8.499999999907,23.600008269715,38.5)); +#32126 = VECTOR('',#32127,1.); +#32127 = DIRECTION('',(-1.,2.467162276942E-16,1.42047624935E-27)); +#32128 = PCURVE('',#30240,#32129); +#32129 = DEFINITIONAL_REPRESENTATION('',(#32130),#32134); +#32130 = LINE('',#32131,#32132); +#32131 = CARTESIAN_POINT('',(6.499999999908,-23.59999999976)); +#32132 = VECTOR('',#32133,1.); +#32133 = DIRECTION('',(1.,-2.467162276942E-16)); +#32134 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32135 = PCURVE('',#32136,#32141); +#32136 = PLANE('',#32137); +#32137 = AXIS2_PLACEMENT_3D('',#32138,#32139,#32140); +#32138 = CARTESIAN_POINT('',(-14.99999999981,23.600008269715,40.)); +#32139 = DIRECTION('',(2.467162276942E-16,1.,-1.106313827174E-59)); +#32140 = DIRECTION('',(1.,-2.467162276942E-16,1.146036670579E-15)); +#32141 = DEFINITIONAL_REPRESENTATION('',(#32142),#32146); +#32142 = LINE('',#32143,#32144); +#32143 = CARTESIAN_POINT('',(6.499999999909,1.5)); +#32144 = VECTOR('',#32145,1.); +#32145 = DIRECTION('',(-1.,-1.14603667058E-15)); +#32146 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32147 = ORIENTED_EDGE('',*,*,#32148,.T.); +#32148 = EDGE_CURVE('',#32121,#32149,#32151,.T.); +#32149 = VERTEX_POINT('',#32150); +#32150 = CARTESIAN_POINT('',(-14.99999999981,-56.59999173034,38.5)); +#32151 = SURFACE_CURVE('',#32152,(#32156,#32163),.PCURVE_S1.); +#32152 = LINE('',#32153,#32154); +#32153 = CARTESIAN_POINT('',(-14.99999999981,-28.29999173019,38.5)); +#32154 = VECTOR('',#32155,1.); +#32155 = DIRECTION('',(-1.960514351287E-30,-1.,1.980689724944E-15)); +#32156 = PCURVE('',#30240,#32157); +#32157 = DEFINITIONAL_REPRESENTATION('',(#32158),#32162); +#32158 = LINE('',#32159,#32160); +#32159 = CARTESIAN_POINT('',(12.999999999817,28.300000000148)); +#32160 = VECTOR('',#32161,1.); +#32161 = DIRECTION('',(1.96051435129E-30,1.)); +#32162 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32163 = PCURVE('',#32164,#32169); +#32164 = PLANE('',#32165); +#32165 = AXIS2_PLACEMENT_3D('',#32166,#32167,#32168); +#32166 = CARTESIAN_POINT('',(-14.99999999981,-56.59999173034,40.)); +#32167 = DIRECTION('',(-1.,1.960514351287E-30,4.484155085839E-44)); +#32168 = DIRECTION('',(1.960514351287E-30,1.,-1.710690767248E-15)); +#32169 = DEFINITIONAL_REPRESENTATION('',(#32170),#32174); +#32170 = LINE('',#32171,#32172); +#32171 = CARTESIAN_POINT('',(28.300000000149,1.5)); +#32172 = VECTOR('',#32173,1.); +#32173 = DIRECTION('',(-1.,-2.699989576963E-16)); +#32174 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32175 = ORIENTED_EDGE('',*,*,#32176,.T.); +#32176 = EDGE_CURVE('',#32149,#32091,#32177,.T.); +#32177 = SURFACE_CURVE('',#32178,(#32182,#32189),.PCURVE_S1.); +#32178 = LINE('',#32179,#32180); +#32179 = CARTESIAN_POINT('',(9.500000000115,-56.59999173034,38.5)); +#32180 = VECTOR('',#32181,1.); +#32181 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#32182 = PCURVE('',#30240,#32183); +#32183 = DEFINITIONAL_REPRESENTATION('',(#32184),#32188); +#32184 = LINE('',#32185,#32186); +#32185 = CARTESIAN_POINT('',(-11.50000000011,56.600000000297)); +#32186 = VECTOR('',#32187,1.); +#32187 = DIRECTION('',(-1.,-8.723744686338E-59)); +#32188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32189 = PCURVE('',#32190,#32195); +#32190 = PLANE('',#32191); +#32191 = AXIS2_PLACEMENT_3D('',#32192,#32193,#32194); +#32192 = CARTESIAN_POINT('',(21.000000000228,-56.59999173034,40.)); +#32193 = DIRECTION('',(5.205416047476E-145,-1.,-7.171696191935E-87)); +#32194 = DIRECTION('',(-1.,8.21902682621E-102,-1.146036670579E-15)); +#32195 = DEFINITIONAL_REPRESENTATION('',(#32196),#32200); +#32196 = LINE('',#32197,#32198); +#32197 = CARTESIAN_POINT('',(11.500000000113,1.5)); +#32198 = VECTOR('',#32199,1.); +#32199 = DIRECTION('',(-1.,1.14603667058E-15)); +#32200 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32201 = ADVANCED_FACE('',(#32202),#30812,.T.); +#32202 = FACE_BOUND('',#32203,.T.); +#32203 = EDGE_LOOP('',(#32204,#32205,#32226,#32227,#32250)); +#32204 = ORIENTED_EDGE('',*,*,#30791,.T.); +#32205 = ORIENTED_EDGE('',*,*,#32206,.T.); +#32206 = EDGE_CURVE('',#30764,#31239,#32207,.T.); +#32207 = SURFACE_CURVE('',#32208,(#32212,#32219),.PCURVE_S1.); +#32208 = LINE('',#32209,#32210); +#32209 = CARTESIAN_POINT('',(-28.49999999986,-68.39999173007,38.5)); +#32210 = VECTOR('',#32211,1.); +#32211 = DIRECTION('',(9.203377230688E-29,-1.7763568394E-15,-1.)); +#32212 = PCURVE('',#30812,#32213); +#32213 = DEFINITIONAL_REPRESENTATION('',(#32214),#32218); +#32214 = LINE('',#32215,#32216); +#32215 = CARTESIAN_POINT('',(-0.785398163381,0.)); +#32216 = VECTOR('',#32217,1.); +#32217 = DIRECTION('',(0.,-1.)); +#32218 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32219 = PCURVE('',#30779,#32220); +#32220 = DEFINITIONAL_REPRESENTATION('',(#32221),#32225); +#32221 = LINE('',#32222,#32223); +#32222 = CARTESIAN_POINT('',(1.500000000162,9.8790343593E-26)); +#32223 = VECTOR('',#32224,1.); +#32224 = DIRECTION('',(8.161364731479E-27,-1.)); +#32225 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32226 = ORIENTED_EDGE('',*,*,#31238,.T.); +#32227 = ORIENTED_EDGE('',*,*,#32228,.T.); +#32228 = EDGE_CURVE('',#31211,#32229,#32231,.T.); +#32229 = VERTEX_POINT('',#32230); +#32230 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173002,40.)); +#32231 = SURFACE_CURVE('',#32232,(#32236,#32243),.PCURVE_S1.); +#32232 = LINE('',#32233,#32234); +#32233 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173007,38.5)); +#32234 = VECTOR('',#32235,1.); +#32235 = DIRECTION('',(-9.203377230688E-29,1.7763568394E-15,1.)); +#32236 = PCURVE('',#30812,#32237); +#32237 = DEFINITIONAL_REPRESENTATION('',(#32238),#32242); +#32238 = LINE('',#32239,#32240); +#32239 = CARTESIAN_POINT('',(0.785398163381,0.)); +#32240 = VECTOR('',#32241,1.); +#32241 = DIRECTION('',(0.,1.)); +#32242 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32243 = PCURVE('',#31226,#32244); +#32244 = DEFINITIONAL_REPRESENTATION('',(#32245),#32249); +#32245 = LINE('',#32246,#32247); +#32246 = CARTESIAN_POINT('',(-4.8700599109E-11,-9.646077625382E-26)); +#32247 = VECTOR('',#32248,1.); +#32248 = DIRECTION('',(-2.043328855439E-16,1.)); +#32249 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32250 = ORIENTED_EDGE('',*,*,#32251,.T.); +#32251 = EDGE_CURVE('',#32229,#30792,#32252,.T.); +#32252 = SURFACE_CURVE('',#32253,(#32257,#32264),.PCURVE_S1.); +#32253 = LINE('',#32254,#32255); +#32254 = CARTESIAN_POINT('',(-26.99999999991,-66.89999173002,38.5)); +#32255 = VECTOR('',#32256,1.); +#32256 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32257 = PCURVE('',#30812,#32258); +#32258 = DEFINITIONAL_REPRESENTATION('',(#32259),#32263); +#32259 = LINE('',#32260,#32261); +#32260 = CARTESIAN_POINT('',(0.785398163414,0.)); +#32261 = VECTOR('',#32262,1.); +#32262 = DIRECTION('',(9.51619735393E-16,1.)); +#32263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32264 = PCURVE('',#30840,#32265); +#32265 = DEFINITIONAL_REPRESENTATION('',(#32266),#32270); +#32266 = LINE('',#32267,#32268); +#32267 = CARTESIAN_POINT('',(0.,0.)); +#32268 = VECTOR('',#32269,1.); +#32269 = DIRECTION('',(8.069935906037E-27,1.)); +#32270 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32271 = ADVANCED_FACE('',(#32272),#30779,.T.); +#32272 = FACE_BOUND('',#32273,.T.); +#32273 = EDGE_LOOP('',(#32274,#32275,#32276,#32297)); +#32274 = ORIENTED_EDGE('',*,*,#32206,.F.); +#32275 = ORIENTED_EDGE('',*,*,#30763,.F.); +#32276 = ORIENTED_EDGE('',*,*,#32277,.F.); +#32277 = EDGE_CURVE('',#31263,#30735,#32278,.T.); +#32278 = SURFACE_CURVE('',#32279,(#32283,#32290),.PCURVE_S1.); +#32279 = LINE('',#32280,#32281); +#32280 = CARTESIAN_POINT('',(-30.00000000003,-68.39999173012,38.5)); +#32281 = VECTOR('',#32282,1.); +#32282 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32283 = PCURVE('',#30779,#32284); +#32284 = DEFINITIONAL_REPRESENTATION('',(#32285),#32289); +#32285 = LINE('',#32286,#32287); +#32286 = CARTESIAN_POINT('',(0.,0.)); +#32287 = VECTOR('',#32288,1.); +#32288 = DIRECTION('',(-8.069330959173E-27,1.)); +#32289 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32290 = PCURVE('',#30751,#32291); +#32291 = DEFINITIONAL_REPRESENTATION('',(#32292),#32296); +#32292 = LINE('',#32293,#32294); +#32293 = CARTESIAN_POINT('',(1.570796326795,-1.42108547152E-14)); +#32294 = VECTOR('',#32295,1.); +#32295 = DIRECTION('',(0.,1.)); +#32296 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32297 = ORIENTED_EDGE('',*,*,#31262,.T.); +#32298 = ADVANCED_FACE('',(#32299),#31142,.T.); +#32299 = FACE_BOUND('',#32300,.T.); +#32300 = EDGE_LOOP('',(#32301,#32336,#32364,#32385,#32386)); +#32301 = ORIENTED_EDGE('',*,*,#32302,.T.); +#32302 = EDGE_CURVE('',#32303,#32305,#32307,.T.); +#32303 = VERTEX_POINT('',#32304); +#32304 = CARTESIAN_POINT('',(24.500000000085,-68.39999173014,43.5)); +#32305 = VERTEX_POINT('',#32306); +#32306 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,43.5)); +#32307 = SURFACE_CURVE('',#32308,(#32313,#32320),.PCURVE_S1.); +#32308 = CIRCLE('',#32309,1.5); +#32309 = AXIS2_PLACEMENT_3D('',#32310,#32311,#32312); +#32310 = CARTESIAN_POINT('',(24.500000000089,-66.89999173014,43.5)); +#32311 = DIRECTION('',(-1.421038649714E-27,-1.980689724944E-15,-1.)); +#32312 = DIRECTION('',(-0.707106781188,-0.707106781185, + 1.400559135932E-15)); +#32313 = PCURVE('',#31142,#32314); +#32314 = DEFINITIONAL_REPRESENTATION('',(#32315),#32319); +#32315 = LINE('',#32316,#32317); +#32316 = CARTESIAN_POINT('',(6.28318530718,5.)); +#32317 = VECTOR('',#32318,1.); +#32318 = DIRECTION('',(-1.,0.)); +#32319 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32320 = PCURVE('',#32321,#32326); +#32321 = PLANE('',#32322); +#32322 = AXIS2_PLACEMENT_3D('',#32323,#32324,#32325); +#32323 = CARTESIAN_POINT('',(27.900000000128,-63.49999173025,43.5)); +#32324 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#32325 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#32326 = DEFINITIONAL_REPRESENTATION('',(#32327),#32335); +#32327 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#32328,#32329,#32330,#32331 + ,#32332,#32333,#32334),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#32328 = CARTESIAN_POINT('',(4.460660171821,4.460660171666)); +#32329 = CARTESIAN_POINT('',(6.297777478904,2.623542864574)); +#32330 = CARTESIAN_POINT('',(3.788228567689,1.951111260454)); +#32331 = CARTESIAN_POINT('',(1.278679656474,1.278679656334)); +#32332 = CARTESIAN_POINT('',(1.951111260606,3.788228567546)); +#32333 = CARTESIAN_POINT('',(2.623542864738,6.297777478757)); +#32334 = CARTESIAN_POINT('',(4.460660171821,4.460660171666)); +#32335 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32336 = ORIENTED_EDGE('',*,*,#32337,.F.); +#32337 = EDGE_CURVE('',#32338,#32305,#32340,.T.); +#32338 = VERTEX_POINT('',#32339); +#32339 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,40.)); +#32340 = SURFACE_CURVE('',#32341,(#32345,#32352),.PCURVE_S1.); +#32341 = LINE('',#32342,#32343); +#32342 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,38.5)); +#32343 = VECTOR('',#32344,1.); +#32344 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32345 = PCURVE('',#31142,#32346); +#32346 = DEFINITIONAL_REPRESENTATION('',(#32347),#32351); +#32347 = LINE('',#32348,#32349); +#32348 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#32349 = VECTOR('',#32350,1.); +#32350 = DIRECTION('',(-3.298948416029E-15,1.)); +#32351 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32352 = PCURVE('',#32353,#32358); +#32353 = PLANE('',#32354); +#32354 = AXIS2_PLACEMENT_3D('',#32355,#32356,#32357); +#32355 = CARTESIAN_POINT('',(26.000062083639,-66.89999173014,38.5)); +#32356 = DIRECTION('',(2.418755841333E-12,1.,-1.7763568394E-15)); +#32357 = DIRECTION('',(-1.,2.418755841333E-12,-3.369839924431E-27)); +#32358 = DEFINITIONAL_REPRESENTATION('',(#32359),#32363); +#32359 = LINE('',#32360,#32361); +#32360 = CARTESIAN_POINT('',(3.00006208355,1.011919531578E-26)); +#32361 = VECTOR('',#32362,1.); +#32362 = DIRECTION('',(9.267335571612E-28,1.)); +#32363 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32364 = ORIENTED_EDGE('',*,*,#32365,.T.); +#32365 = EDGE_CURVE('',#32338,#31126,#32366,.T.); +#32366 = SURFACE_CURVE('',#32367,(#32371,#32378),.PCURVE_S1.); +#32367 = LINE('',#32368,#32369); +#32368 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,38.5)); +#32369 = VECTOR('',#32370,1.); +#32370 = DIRECTION('',(-4.259848892852E-27,-1.7763568394E-15,-1.)); +#32371 = PCURVE('',#31142,#32372); +#32372 = DEFINITIONAL_REPRESENTATION('',(#32373),#32377); +#32373 = LINE('',#32374,#32375); +#32374 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#32375 = VECTOR('',#32376,1.); +#32376 = DIRECTION('',(-5.329070518201E-15,-1.)); +#32377 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32378 = PCURVE('',#31170,#32379); +#32379 = DEFINITIONAL_REPRESENTATION('',(#32380),#32384); +#32380 = LINE('',#32381,#32382); +#32381 = CARTESIAN_POINT('',(0.299999999586,-5.94206916664E-16)); +#32382 = VECTOR('',#32383,1.); +#32383 = DIRECTION('',(-2.043328855439E-16,-1.)); +#32384 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32385 = ORIENTED_EDGE('',*,*,#31125,.T.); +#32386 = ORIENTED_EDGE('',*,*,#32387,.T.); +#32387 = EDGE_CURVE('',#31098,#32303,#32388,.T.); +#32388 = SURFACE_CURVE('',#32389,(#32393,#32400),.PCURVE_S1.); +#32389 = LINE('',#32390,#32391); +#32390 = CARTESIAN_POINT('',(24.500000000085,-68.39999173014,38.5)); +#32391 = VECTOR('',#32392,1.); +#32392 = DIRECTION('',(4.259848892852E-27,1.7763568394E-15,1.)); +#32393 = PCURVE('',#31142,#32394); +#32394 = DEFINITIONAL_REPRESENTATION('',(#32395),#32399); +#32395 = LINE('',#32396,#32397); +#32396 = CARTESIAN_POINT('',(0.785398163397,0.)); +#32397 = VECTOR('',#32398,1.); +#32398 = DIRECTION('',(1.443289932013E-15,1.)); +#32399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32400 = PCURVE('',#31113,#32401); +#32401 = DEFINITIONAL_REPRESENTATION('',(#32402),#32406); +#32402 = LINE('',#32403,#32404); +#32403 = CARTESIAN_POINT('',(1.5,-5.0470024799E-27)); +#32404 = VECTOR('',#32405,1.); +#32405 = DIRECTION('',(3.333113888383E-27,1.)); +#32406 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32407 = ADVANCED_FACE('',(#32408),#32321,.T.); +#32408 = FACE_BOUND('',#32409,.T.); +#32409 = EDGE_LOOP('',(#32410,#32411,#32434,#32458,#32481,#32509,#32537, + #32570)); +#32410 = ORIENTED_EDGE('',*,*,#32302,.F.); +#32411 = ORIENTED_EDGE('',*,*,#32412,.T.); +#32412 = EDGE_CURVE('',#32303,#32413,#32415,.T.); +#32413 = VERTEX_POINT('',#32414); +#32414 = CARTESIAN_POINT('',(26.000070869049,-68.39999173014,43.5)); +#32415 = SURFACE_CURVE('',#32416,(#32420,#32427),.PCURVE_S1.); +#32416 = LINE('',#32417,#32418); +#32417 = CARTESIAN_POINT('',(23.000000000085,-68.39999173014,43.5)); +#32418 = VECTOR('',#32419,1.); +#32419 = DIRECTION('',(1.,-2.418748758244E-12,3.369825895028E-27)); +#32420 = PCURVE('',#32321,#32421); +#32421 = DEFINITIONAL_REPRESENTATION('',(#32422),#32426); +#32422 = LINE('',#32423,#32424); +#32423 = CARTESIAN_POINT('',(4.900000000042,4.899999999885)); +#32424 = VECTOR('',#32425,1.); +#32425 = DIRECTION('',(-1.,2.418748758244E-12)); +#32426 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32427 = PCURVE('',#31113,#32428); +#32428 = DEFINITIONAL_REPRESENTATION('',(#32429),#32433); +#32429 = LINE('',#32430,#32431); +#32430 = CARTESIAN_POINT('',(-1.752335772084E-26,5.)); +#32431 = VECTOR('',#32432,1.); +#32432 = DIRECTION('',(1.,0.)); +#32433 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32434 = ORIENTED_EDGE('',*,*,#32435,.T.); +#32435 = EDGE_CURVE('',#32413,#32436,#32438,.T.); +#32436 = VERTEX_POINT('',#32437); +#32437 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,43.5)); +#32438 = SURFACE_CURVE('',#32439,(#32444,#32451),.PCURVE_S1.); +#32439 = CIRCLE('',#32440,6.800000000105); +#32440 = AXIS2_PLACEMENT_3D('',#32441,#32442,#32443); +#32441 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,43.5)); +#32442 = DIRECTION('',(1.420964916416E-27,1.980689724944E-15,1.)); +#32443 = DIRECTION('',(1.042190969326E-05,-0.999999999946, + 1.980689724837E-15)); +#32444 = PCURVE('',#32321,#32445); +#32445 = DEFINITIONAL_REPRESENTATION('',(#32446),#32450); +#32446 = CIRCLE('',#32447,6.800000000105); +#32447 = AXIS2_PLACEMENT_2D('',#32448,#32449); +#32448 = CARTESIAN_POINT('',(1.900000000065,-1.899999999849)); +#32449 = DIRECTION('',(-1.042190969326E-05,0.999999999946)); +#32450 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32451 = PCURVE('',#31085,#32452); +#32452 = DEFINITIONAL_REPRESENTATION('',(#32453),#32457); +#32453 = LINE('',#32454,#32455); +#32454 = CARTESIAN_POINT('',(0.,5.)); +#32455 = VECTOR('',#32456,1.); +#32456 = DIRECTION('',(1.,0.)); +#32457 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32458 = ORIENTED_EDGE('',*,*,#32459,.T.); +#32459 = EDGE_CURVE('',#32436,#32460,#32462,.T.); +#32460 = VERTEX_POINT('',#32461); +#32461 = CARTESIAN_POINT('',(32.800000000168,-60.09999173036,43.5)); +#32462 = SURFACE_CURVE('',#32463,(#32467,#32474),.PCURVE_S1.); +#32463 = LINE('',#32464,#32465); +#32464 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,43.5)); +#32465 = VECTOR('',#32466,1.); +#32466 = DIRECTION('',(-2.250051996538E-13,1.,-1.980689724944E-15)); +#32467 = PCURVE('',#32321,#32468); +#32468 = DEFINITIONAL_REPRESENTATION('',(#32469),#32473); +#32469 = LINE('',#32470,#32471); +#32470 = CARTESIAN_POINT('',(-4.90000000004,-1.899999999845)); +#32471 = VECTOR('',#32472,1.); +#32472 = DIRECTION('',(2.250051996538E-13,-1.)); +#32473 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32474 = PCURVE('',#31056,#32475); +#32475 = DEFINITIONAL_REPRESENTATION('',(#32476),#32480); +#32476 = LINE('',#32477,#32478); +#32477 = CARTESIAN_POINT('',(-9.903448624721E-15,5.)); +#32478 = VECTOR('',#32479,1.); +#32479 = DIRECTION('',(1.,0.)); +#32480 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32481 = ORIENTED_EDGE('',*,*,#32482,.F.); +#32482 = EDGE_CURVE('',#32483,#32460,#32485,.T.); +#32483 = VERTEX_POINT('',#32484); +#32484 = CARTESIAN_POINT('',(31.300000000167,-58.59999173036,43.5)); +#32485 = SURFACE_CURVE('',#32486,(#32491,#32502),.PCURVE_S1.); +#32486 = CIRCLE('',#32487,1.5); +#32487 = AXIS2_PLACEMENT_3D('',#32488,#32489,#32490); +#32488 = CARTESIAN_POINT('',(31.300000000168,-60.09999173036,43.5)); +#32489 = DIRECTION('',(-1.421037928292E-27,-1.980689724944E-15,-1.)); +#32490 = DIRECTION('',(0.707106781187,0.707106781186,-1.400559135935E-15 + )); +#32491 = PCURVE('',#32321,#32492); +#32492 = DEFINITIONAL_REPRESENTATION('',(#32493),#32501); +#32493 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#32494,#32495,#32496,#32497 + ,#32498,#32499,#32500),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#32494 = CARTESIAN_POINT('',(-4.46066017182,-4.460660171671)); +#32495 = CARTESIAN_POINT('',(-6.297777478907,-2.623542864583)); +#32496 = CARTESIAN_POINT('',(-3.788228567693,-1.951111260458)); +#32497 = CARTESIAN_POINT('',(-1.278679656479,-1.278679656333)); +#32498 = CARTESIAN_POINT('',(-1.951111260606,-3.788228567546)); +#32499 = CARTESIAN_POINT('',(-2.623542864734,-6.297777478759)); +#32500 = CARTESIAN_POINT('',(-4.46066017182,-4.460660171671)); +#32501 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32502 = PCURVE('',#31028,#32503); +#32503 = DEFINITIONAL_REPRESENTATION('',(#32504),#32508); +#32504 = LINE('',#32505,#32506); +#32505 = CARTESIAN_POINT('',(6.28318530718,5.)); +#32506 = VECTOR('',#32507,1.); +#32507 = DIRECTION('',(-1.,0.)); +#32508 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32509 = ORIENTED_EDGE('',*,*,#32510,.T.); +#32510 = EDGE_CURVE('',#32483,#32511,#32513,.T.); +#32511 = VERTEX_POINT('',#32512); +#32512 = CARTESIAN_POINT('',(31.300000000168,-61.59999173041,43.5)); +#32513 = SURFACE_CURVE('',#32514,(#32518,#32525),.PCURVE_S1.); +#32514 = LINE('',#32515,#32516); +#32515 = CARTESIAN_POINT('',(31.300000000168,-61.59999173041,43.5)); +#32516 = VECTOR('',#32517,1.); +#32517 = DIRECTION('',(2.279657943862E-13,-1.,1.980689724944E-15)); +#32518 = PCURVE('',#32321,#32519); +#32519 = DEFINITIONAL_REPRESENTATION('',(#32520),#32524); +#32520 = LINE('',#32521,#32522); +#32521 = CARTESIAN_POINT('',(-3.40000000004,-1.899999999846)); +#32522 = VECTOR('',#32523,1.); +#32523 = DIRECTION('',(-2.279657943862E-13,1.)); +#32524 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32525 = PCURVE('',#32526,#32531); +#32526 = PLANE('',#32527); +#32527 = AXIS2_PLACEMENT_3D('',#32528,#32529,#32530); +#32528 = CARTESIAN_POINT('',(31.300000000167,-58.59999173036,38.5)); +#32529 = DIRECTION('',(-1.,-2.279657943862E-13,4.049485980072E-28)); +#32530 = DIRECTION('',(2.279657943862E-13,-1.,1.980689724944E-15)); +#32531 = DEFINITIONAL_REPRESENTATION('',(#32532),#32536); +#32532 = LINE('',#32533,#32534); +#32533 = CARTESIAN_POINT('',(3.000000000046,5.)); +#32534 = VECTOR('',#32535,1.); +#32535 = DIRECTION('',(1.,0.)); +#32536 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32537 = ORIENTED_EDGE('',*,*,#32538,.T.); +#32538 = EDGE_CURVE('',#32511,#32539,#32541,.T.); +#32539 = VERTEX_POINT('',#32540); +#32540 = CARTESIAN_POINT('',(26.000062083639,-66.89999173014,43.5)); +#32541 = SURFACE_CURVE('',#32542,(#32547,#32558),.PCURVE_S1.); +#32542 = CIRCLE('',#32543,5.300000000105); +#32543 = AXIS2_PLACEMENT_3D('',#32544,#32545,#32546); +#32544 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,43.5)); +#32545 = DIRECTION('',(-1.42096491516E-27,-1.980689724944E-15,-1.)); +#32546 = DIRECTION('',(1.171388226813E-05,-0.999999999931, + 1.980689724808E-15)); +#32547 = PCURVE('',#32321,#32548); +#32548 = DEFINITIONAL_REPRESENTATION('',(#32549),#32557); +#32549 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#32550,#32551,#32552,#32553 + ,#32554,#32555,#32556),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#32550 = CARTESIAN_POINT('',(1.899937916489,3.399999999892)); +#32551 = CARTESIAN_POINT('',(11.079807196156,3.4001075318)); +#32552 = CARTESIAN_POINT('',(6.489965681686,-4.549946233766)); +#32553 = CARTESIAN_POINT('',(1.900124167217,-12.49999999933)); +#32554 = CARTESIAN_POINT('',(-2.689903597981,-4.550053765674)); +#32555 = CARTESIAN_POINT('',(-7.279931363178,3.399892467984)); +#32556 = CARTESIAN_POINT('',(1.899937916489,3.399999999892)); +#32557 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32558 = PCURVE('',#32559,#32564); +#32559 = CYLINDRICAL_SURFACE('',#32560,5.300000000105); +#32560 = AXIS2_PLACEMENT_3D('',#32561,#32562,#32563); +#32561 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,38.5)); +#32562 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32563 = DIRECTION('',(1.171388226813E-05,-0.999999999931, + 1.776356839278E-15)); +#32564 = DEFINITIONAL_REPRESENTATION('',(#32565),#32569); +#32565 = LINE('',#32566,#32567); +#32566 = CARTESIAN_POINT('',(6.28318530718,5.)); +#32567 = VECTOR('',#32568,1.); +#32568 = DIRECTION('',(-1.,-4.52348927994E-15)); +#32569 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32570 = ORIENTED_EDGE('',*,*,#32571,.T.); +#32571 = EDGE_CURVE('',#32539,#32305,#32572,.T.); +#32572 = SURFACE_CURVE('',#32573,(#32577,#32584),.PCURVE_S1.); +#32573 = LINE('',#32574,#32575); +#32574 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,43.5)); +#32575 = VECTOR('',#32576,1.); +#32576 = DIRECTION('',(-1.,2.418755841333E-12,-3.369839924431E-27)); +#32577 = PCURVE('',#32321,#32578); +#32578 = DEFINITIONAL_REPRESENTATION('',(#32579),#32583); +#32579 = LINE('',#32580,#32581); +#32580 = CARTESIAN_POINT('',(4.900000000039,3.399999999885)); +#32581 = VECTOR('',#32582,1.); +#32582 = DIRECTION('',(1.,-2.418755841333E-12)); +#32583 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32584 = PCURVE('',#32353,#32585); +#32585 = DEFINITIONAL_REPRESENTATION('',(#32586),#32590); +#32586 = LINE('',#32587,#32588); +#32587 = CARTESIAN_POINT('',(3.00006208355,5.)); +#32588 = VECTOR('',#32589,1.); +#32589 = DIRECTION('',(1.,0.)); +#32590 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32591 = ADVANCED_FACE('',(#32592),#31113,.T.); +#32592 = FACE_BOUND('',#32593,.T.); +#32593 = EDGE_LOOP('',(#32594,#32595,#32596,#32617)); +#32594 = ORIENTED_EDGE('',*,*,#32387,.F.); +#32595 = ORIENTED_EDGE('',*,*,#31097,.T.); +#32596 = ORIENTED_EDGE('',*,*,#32597,.T.); +#32597 = EDGE_CURVE('',#31069,#32413,#32598,.T.); +#32598 = SURFACE_CURVE('',#32599,(#32603,#32610),.PCURVE_S1.); +#32599 = LINE('',#32600,#32601); +#32600 = CARTESIAN_POINT('',(26.000070869049,-68.39999173014,38.5)); +#32601 = VECTOR('',#32602,1.); +#32602 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32603 = PCURVE('',#31113,#32604); +#32604 = DEFINITIONAL_REPRESENTATION('',(#32605),#32609); +#32605 = LINE('',#32606,#32607); +#32606 = CARTESIAN_POINT('',(3.000070868964,-1.011918283202E-26)); +#32607 = VECTOR('',#32608,1.); +#32608 = DIRECTION('',(-9.267350044693E-28,1.)); +#32609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32610 = PCURVE('',#31085,#32611); +#32611 = DEFINITIONAL_REPRESENTATION('',(#32612),#32616); +#32612 = LINE('',#32613,#32614); +#32613 = CARTESIAN_POINT('',(0.,-1.42108547152E-14)); +#32614 = VECTOR('',#32615,1.); +#32615 = DIRECTION('',(0.,1.)); +#32616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32617 = ORIENTED_EDGE('',*,*,#32412,.F.); +#32618 = ADVANCED_FACE('',(#32619),#31028,.T.); +#32619 = FACE_BOUND('',#32620,.T.); +#32620 = EDGE_LOOP('',(#32621,#32622,#32643,#32644,#32667)); +#32621 = ORIENTED_EDGE('',*,*,#32482,.T.); +#32622 = ORIENTED_EDGE('',*,*,#32623,.T.); +#32623 = EDGE_CURVE('',#32460,#31012,#32624,.T.); +#32624 = SURFACE_CURVE('',#32625,(#32629,#32636),.PCURVE_S1.); +#32625 = LINE('',#32626,#32627); +#32626 = CARTESIAN_POINT('',(32.800000000168,-60.09999173036,38.5)); +#32627 = VECTOR('',#32628,1.); +#32628 = DIRECTION('',(-3.996895253057E-28,5.088270423583E-40,-1.)); +#32629 = PCURVE('',#31028,#32630); +#32630 = DEFINITIONAL_REPRESENTATION('',(#32631),#32635); +#32631 = LINE('',#32632,#32633); +#32632 = CARTESIAN_POINT('',(-0.785398163397,0.)); +#32633 = VECTOR('',#32634,1.); +#32634 = DIRECTION('',(0.,-1.)); +#32635 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32636 = PCURVE('',#31056,#32637); +#32637 = DEFINITIONAL_REPRESENTATION('',(#32638),#32642); +#32638 = LINE('',#32639,#32640); +#32639 = CARTESIAN_POINT('',(1.500000000047,2.97103458751E-15)); +#32640 = VECTOR('',#32641,1.); +#32641 = DIRECTION('',(1.980689724944E-15,-1.)); +#32642 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32643 = ORIENTED_EDGE('',*,*,#31011,.T.); +#32644 = ORIENTED_EDGE('',*,*,#32645,.T.); +#32645 = EDGE_CURVE('',#30984,#32646,#32648,.T.); +#32646 = VERTEX_POINT('',#32647); +#32647 = CARTESIAN_POINT('',(31.300000000167,-58.59999173036,40.)); +#32648 = SURFACE_CURVE('',#32649,(#32653,#32660),.PCURVE_S1.); +#32649 = LINE('',#32650,#32651); +#32650 = CARTESIAN_POINT('',(31.30000000017,-58.59999173036,38.5)); +#32651 = VECTOR('',#32652,1.); +#32652 = DIRECTION('',(3.996895253057E-28,-5.088270423583E-40,1.)); +#32653 = PCURVE('',#31028,#32654); +#32654 = DEFINITIONAL_REPRESENTATION('',(#32655),#32659); +#32655 = LINE('',#32656,#32657); +#32656 = CARTESIAN_POINT('',(0.785398163397,0.)); +#32657 = VECTOR('',#32658,1.); +#32658 = DIRECTION('',(0.,1.)); +#32659 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32660 = PCURVE('',#30999,#32661); +#32661 = DEFINITIONAL_REPRESENTATION('',(#32662),#32666); +#32662 = LINE('',#32663,#32664); +#32663 = CARTESIAN_POINT('',(-2.302158463863E-12,-2.533671566629E-39)); +#32664 = VECTOR('',#32665,1.); +#32665 = DIRECTION('',(-1.500253020999E-27,1.)); +#32666 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32667 = ORIENTED_EDGE('',*,*,#32668,.T.); +#32668 = EDGE_CURVE('',#32646,#32483,#32669,.T.); +#32669 = SURFACE_CURVE('',#32670,(#32674,#32681),.PCURVE_S1.); +#32670 = LINE('',#32671,#32672); +#32671 = CARTESIAN_POINT('',(31.300000000167,-58.59999173036,38.5)); +#32672 = VECTOR('',#32673,1.); +#32673 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32674 = PCURVE('',#31028,#32675); +#32675 = DEFINITIONAL_REPRESENTATION('',(#32676),#32680); +#32676 = LINE('',#32677,#32678); +#32677 = CARTESIAN_POINT('',(0.785398163398,0.)); +#32678 = VECTOR('',#32679,1.); +#32679 = DIRECTION('',(-9.833403932394E-16,1.)); +#32680 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32681 = PCURVE('',#32526,#32682); +#32682 = DEFINITIONAL_REPRESENTATION('',(#32683),#32687); +#32683 = LINE('',#32684,#32685); +#32684 = CARTESIAN_POINT('',(0.,0.)); +#32685 = VECTOR('',#32686,1.); +#32686 = DIRECTION('',(2.043328855439E-16,1.)); +#32687 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32688 = ADVANCED_FACE('',(#32689),#31056,.T.); +#32689 = FACE_BOUND('',#32690,.T.); +#32690 = EDGE_LOOP('',(#32691,#32692,#32693,#32714)); +#32691 = ORIENTED_EDGE('',*,*,#32623,.F.); +#32692 = ORIENTED_EDGE('',*,*,#32459,.F.); +#32693 = ORIENTED_EDGE('',*,*,#32694,.F.); +#32694 = EDGE_CURVE('',#31041,#32436,#32695,.T.); +#32695 = SURFACE_CURVE('',#32696,(#32700,#32707),.PCURVE_S1.); +#32696 = LINE('',#32697,#32698); +#32697 = CARTESIAN_POINT('',(32.800000000168,-61.59999173041,38.5)); +#32698 = VECTOR('',#32699,1.); +#32699 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32700 = PCURVE('',#31056,#32701); +#32701 = DEFINITIONAL_REPRESENTATION('',(#32702),#32706); +#32702 = LINE('',#32703,#32704); +#32703 = CARTESIAN_POINT('',(0.,0.)); +#32704 = VECTOR('',#32705,1.); +#32705 = DIRECTION('',(-2.043328855439E-16,1.)); +#32706 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32707 = PCURVE('',#31085,#32708); +#32708 = DEFINITIONAL_REPRESENTATION('',(#32709),#32713); +#32709 = LINE('',#32710,#32711); +#32710 = CARTESIAN_POINT('',(1.570785904884,0.)); +#32711 = VECTOR('',#32712,1.); +#32712 = DIRECTION('',(0.,1.)); +#32713 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32714 = ORIENTED_EDGE('',*,*,#31040,.T.); +#32715 = ADVANCED_FACE('',(#32716),#30464,.T.); +#32716 = FACE_BOUND('',#32717,.T.); +#32717 = EDGE_LOOP('',(#32718,#32719,#32740,#32741,#32764)); +#32718 = ORIENTED_EDGE('',*,*,#30443,.T.); +#32719 = ORIENTED_EDGE('',*,*,#32720,.T.); +#32720 = EDGE_CURVE('',#30416,#31728,#32721,.T.); +#32721 = SURFACE_CURVE('',#32722,(#32726,#32733),.PCURVE_S1.); +#32722 = LINE('',#32723,#32724); +#32723 = CARTESIAN_POINT('',(24.500000000311,68.400008269824,38.5)); +#32724 = VECTOR('',#32725,1.); +#32725 = DIRECTION('',(5.259072698692E-29,-1.7763568394E-15,-1.)); +#32726 = PCURVE('',#30464,#32727); +#32727 = DEFINITIONAL_REPRESENTATION('',(#32728),#32732); +#32728 = LINE('',#32729,#32730); +#32729 = CARTESIAN_POINT('',(-0.785398163439,0.)); +#32730 = VECTOR('',#32731,1.); +#32731 = DIRECTION('',(-8.881784197001E-16,-1.)); +#32732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32733 = PCURVE('',#30431,#32734); +#32734 = DEFINITIONAL_REPRESENTATION('',(#32735),#32739); +#32735 = LINE('',#32736,#32737); +#32736 = CARTESIAN_POINT('',(1.500016445482,2.450019096037E-25)); +#32737 = VECTOR('',#32738,1.); +#32738 = DIRECTION('',(1.552293829016E-26,-1.)); +#32739 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32740 = ORIENTED_EDGE('',*,*,#31727,.T.); +#32741 = ORIENTED_EDGE('',*,*,#32742,.T.); +#32742 = EDGE_CURVE('',#31700,#32743,#32745,.T.); +#32743 = VERTEX_POINT('',#32744); +#32744 = CARTESIAN_POINT('',(23.000000000186,66.900008269948,40.)); +#32745 = SURFACE_CURVE('',#32746,(#32750,#32757),.PCURVE_S1.); +#32746 = LINE('',#32747,#32748); +#32747 = CARTESIAN_POINT('',(23.000000000186,66.900008269824,38.5)); +#32748 = VECTOR('',#32749,1.); +#32749 = DIRECTION('',(-5.259072698692E-29,1.7763568394E-15,1.)); +#32750 = PCURVE('',#30464,#32751); +#32751 = DEFINITIONAL_REPRESENTATION('',(#32752),#32756); +#32752 = LINE('',#32753,#32754); +#32753 = CARTESIAN_POINT('',(0.785398163439,0.)); +#32754 = VECTOR('',#32755,1.); +#32755 = DIRECTION('',(5.033011044967E-15,1.)); +#32756 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32757 = PCURVE('',#31715,#32758); +#32758 = DEFINITIONAL_REPRESENTATION('',(#32759),#32763); +#32759 = LINE('',#32760,#32761); +#32760 = CARTESIAN_POINT('',(1.247997261089E-10,-2.471895351798E-25)); +#32761 = VECTOR('',#32762,1.); +#32762 = DIRECTION('',(2.043328855439E-16,1.)); +#32763 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32764 = ORIENTED_EDGE('',*,*,#32765,.T.); +#32765 = EDGE_CURVE('',#32743,#30444,#32766,.T.); +#32766 = SURFACE_CURVE('',#32767,(#32771,#32778),.PCURVE_S1.); +#32767 = LINE('',#32768,#32769); +#32768 = CARTESIAN_POINT('',(23.000000000186,66.900008269948,38.5)); +#32769 = VECTOR('',#32770,1.); +#32770 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32771 = PCURVE('',#30464,#32772); +#32772 = DEFINITIONAL_REPRESENTATION('',(#32773),#32777); +#32773 = LINE('',#32774,#32775); +#32774 = CARTESIAN_POINT('',(0.785398163356,0.)); +#32775 = VECTOR('',#32776,1.); +#32776 = DIRECTION('',(-3.235507100336E-15,1.)); +#32777 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32778 = PCURVE('',#30492,#32779); +#32779 = DEFINITIONAL_REPRESENTATION('',(#32780),#32784); +#32780 = LINE('',#32781,#32782); +#32781 = CARTESIAN_POINT('',(0.,0.)); +#32782 = VECTOR('',#32783,1.); +#32783 = DIRECTION('',(-1.430644026125E-27,1.)); +#32784 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32785 = ADVANCED_FACE('',(#32786),#30431,.T.); +#32786 = FACE_BOUND('',#32787,.T.); +#32787 = EDGE_LOOP('',(#32788,#32789,#32790,#32811)); +#32788 = ORIENTED_EDGE('',*,*,#32720,.F.); +#32789 = ORIENTED_EDGE('',*,*,#30415,.F.); +#32790 = ORIENTED_EDGE('',*,*,#32791,.F.); +#32791 = EDGE_CURVE('',#31752,#30387,#32792,.T.); +#32792 = SURFACE_CURVE('',#32793,(#32797,#32804),.PCURVE_S1.); +#32793 = LINE('',#32794,#32795); +#32794 = CARTESIAN_POINT('',(26.000016445792,68.400008269699,38.5)); +#32795 = VECTOR('',#32796,1.); +#32796 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32797 = PCURVE('',#30431,#32798); +#32798 = DEFINITIONAL_REPRESENTATION('',(#32799),#32803); +#32799 = LINE('',#32800,#32801); +#32800 = CARTESIAN_POINT('',(0.,0.)); +#32801 = VECTOR('',#32802,1.); +#32802 = DIRECTION('',(-1.557552901715E-26,1.)); +#32803 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32804 = PCURVE('',#30403,#32805); +#32805 = DEFINITIONAL_REPRESENTATION('',(#32806),#32810); +#32806 = LINE('',#32807,#32808); +#32807 = CARTESIAN_POINT('',(1.570793908318,1.42108547152E-14)); +#32808 = VECTOR('',#32809,1.); +#32809 = DIRECTION('',(0.,1.)); +#32810 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32811 = ORIENTED_EDGE('',*,*,#31751,.T.); +#32812 = ADVANCED_FACE('',(#32813),#31631,.T.); +#32813 = FACE_BOUND('',#32814,.T.); +#32814 = EDGE_LOOP('',(#32815,#32850,#32878,#32899,#32900)); +#32815 = ORIENTED_EDGE('',*,*,#32816,.T.); +#32816 = EDGE_CURVE('',#32817,#32819,#32821,.T.); +#32817 = VERTEX_POINT('',#32818); +#32818 = CARTESIAN_POINT('',(-28.49999999977,68.400008269883,43.5)); +#32819 = VERTEX_POINT('',#32820); +#32820 = CARTESIAN_POINT('',(-26.99999999982,66.900008269833,43.5)); +#32821 = SURFACE_CURVE('',#32822,(#32827,#32834),.PCURVE_S1.); +#32822 = CIRCLE('',#32823,1.5); +#32823 = AXIS2_PLACEMENT_3D('',#32824,#32825,#32826); +#32824 = CARTESIAN_POINT('',(-28.49999999982,66.900008269883,43.5)); +#32825 = DIRECTION('',(-1.421157955021E-27,-1.980689724944E-15,-1.)); +#32826 = DIRECTION('',(0.707106781198,0.707106781175,-1.400559135914E-15 + )); +#32827 = PCURVE('',#31631,#32828); +#32828 = DEFINITIONAL_REPRESENTATION('',(#32829),#32833); +#32829 = LINE('',#32830,#32831); +#32830 = CARTESIAN_POINT('',(12.566370614359,5.)); +#32831 = VECTOR('',#32832,1.); +#32832 = DIRECTION('',(-1.,0.)); +#32833 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32834 = PCURVE('',#32835,#32840); +#32835 = PLANE('',#32836); +#32836 = AXIS2_PLACEMENT_3D('',#32837,#32838,#32839); +#32837 = CARTESIAN_POINT('',(-31.89999999999,63.500008269839,43.5)); +#32838 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#32839 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#32840 = DEFINITIONAL_REPRESENTATION('',(#32841),#32849); +#32841 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#32842,#32843,#32844,#32845 + ,#32846,#32847,#32848),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#32842 = CARTESIAN_POINT('',(-4.460660171968,-4.460660171807)); +#32843 = CARTESIAN_POINT('',(-6.297777479027,-2.623542864691)); +#32844 = CARTESIAN_POINT('',(-3.788228567803,-1.951111260604)); +#32845 = CARTESIAN_POINT('',(-1.278679656579,-1.278679656518)); +#32846 = CARTESIAN_POINT('',(-1.951111260744,-3.788228567721)); +#32847 = CARTESIAN_POINT('',(-2.62354286491,-6.297777478924)); +#32848 = CARTESIAN_POINT('',(-4.460660171968,-4.460660171807)); +#32849 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32850 = ORIENTED_EDGE('',*,*,#32851,.F.); +#32851 = EDGE_CURVE('',#32852,#32819,#32854,.T.); +#32852 = VERTEX_POINT('',#32853); +#32853 = CARTESIAN_POINT('',(-26.99999999982,66.900008269833,40.)); +#32854 = SURFACE_CURVE('',#32855,(#32859,#32866),.PCURVE_S1.); +#32855 = LINE('',#32856,#32857); +#32856 = CARTESIAN_POINT('',(-26.99999999982,66.900008269833,38.5)); +#32857 = VECTOR('',#32858,1.); +#32858 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#32859 = PCURVE('',#31631,#32860); +#32860 = DEFINITIONAL_REPRESENTATION('',(#32861),#32865); +#32861 = LINE('',#32862,#32863); +#32862 = CARTESIAN_POINT('',(5.497787143765,0.)); +#32863 = VECTOR('',#32864,1.); +#32864 = DIRECTION('',(7.612957883144E-16,1.)); +#32865 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32866 = PCURVE('',#32867,#32872); +#32867 = PLANE('',#32868); +#32868 = AXIS2_PLACEMENT_3D('',#32869,#32870,#32871); +#32869 = CARTESIAN_POINT('',(-29.99999999995,66.900008269933,38.5)); +#32870 = DIRECTION('',(-3.324451824797E-11,-1.,1.7763568394E-15)); +#32871 = DIRECTION('',(1.,-3.324451824797E-11,6.442611078683E-26)); +#32872 = DEFINITIONAL_REPRESENTATION('',(#32873),#32877); +#32873 = LINE('',#32874,#32875); +#32874 = CARTESIAN_POINT('',(3.000000000127,-1.93275176925E-25)); +#32875 = VECTOR('',#32876,1.); +#32876 = DIRECTION('',(5.371983424479E-27,1.)); +#32877 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32878 = ORIENTED_EDGE('',*,*,#32879,.T.); +#32879 = EDGE_CURVE('',#32852,#31615,#32880,.T.); +#32880 = SURFACE_CURVE('',#32881,(#32885,#32892),.PCURVE_S1.); +#32881 = LINE('',#32882,#32883); +#32882 = CARTESIAN_POINT('',(-26.99999999982,66.900008269886,38.5)); +#32883 = VECTOR('',#32884,1.); +#32884 = DIRECTION('',(3.181738981772E-27,-1.7763568394E-15,-1.)); +#32885 = PCURVE('',#31631,#32886); +#32886 = DEFINITIONAL_REPRESENTATION('',(#32887),#32891); +#32887 = LINE('',#32888,#32889); +#32888 = CARTESIAN_POINT('',(5.4977871438,0.)); +#32889 = VECTOR('',#32890,1.); +#32890 = DIRECTION('',(0.,-1.)); +#32891 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32892 = PCURVE('',#31659,#32893); +#32893 = DEFINITIONAL_REPRESENTATION('',(#32894),#32898); +#32894 = LINE('',#32895,#32896); +#32895 = CARTESIAN_POINT('',(0.300000000288,5.942069180531E-16)); +#32896 = VECTOR('',#32897,1.); +#32897 = DIRECTION('',(2.043328855439E-16,-1.)); +#32898 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32899 = ORIENTED_EDGE('',*,*,#31614,.T.); +#32900 = ORIENTED_EDGE('',*,*,#32901,.T.); +#32901 = EDGE_CURVE('',#31587,#32817,#32902,.T.); +#32902 = SURFACE_CURVE('',#32903,(#32907,#32914),.PCURVE_S1.); +#32903 = LINE('',#32904,#32905); +#32904 = CARTESIAN_POINT('',(-28.49999999977,68.400008269883,38.5)); +#32905 = VECTOR('',#32906,1.); +#32906 = DIRECTION('',(-3.181738981772E-27,1.7763568394E-15,1.)); +#32907 = PCURVE('',#31631,#32908); +#32908 = DEFINITIONAL_REPRESENTATION('',(#32909),#32913); +#32909 = LINE('',#32910,#32911); +#32910 = CARTESIAN_POINT('',(7.06858347056,0.)); +#32911 = VECTOR('',#32912,1.); +#32912 = DIRECTION('',(-6.661338147751E-16,1.)); +#32913 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32914 = PCURVE('',#31602,#32915); +#32915 = DEFINITIONAL_REPRESENTATION('',(#32916),#32920); +#32916 = LINE('',#32917,#32918); +#32917 = CARTESIAN_POINT('',(1.499999999947,9.663758846189E-26)); +#32918 = VECTOR('',#32919,1.); +#32919 = DIRECTION('',(-2.190244442707E-27,1.)); +#32920 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32921 = ADVANCED_FACE('',(#32922),#31659,.T.); +#32922 = FACE_BOUND('',#32923,.T.); +#32923 = EDGE_LOOP('',(#32924,#32925,#32948,#32969)); +#32924 = ORIENTED_EDGE('',*,*,#32879,.F.); +#32925 = ORIENTED_EDGE('',*,*,#32926,.F.); +#32926 = EDGE_CURVE('',#32927,#32852,#32929,.T.); +#32927 = VERTEX_POINT('',#32928); +#32928 = CARTESIAN_POINT('',(-26.99999999982,66.600008269598,40.)); +#32929 = SURFACE_CURVE('',#32930,(#32934,#32941),.PCURVE_S1.); +#32930 = LINE('',#32931,#32932); +#32931 = CARTESIAN_POINT('',(-26.99999999982,66.600008269586,40.)); +#32932 = VECTOR('',#32933,1.); +#32933 = DIRECTION('',(-1.791159811587E-12,1.,-1.980689724944E-15)); +#32934 = PCURVE('',#31659,#32935); +#32935 = DEFINITIONAL_REPRESENTATION('',(#32936),#32940); +#32936 = LINE('',#32937,#32938); +#32937 = CARTESIAN_POINT('',(-1.179798044821E-11,1.5)); +#32938 = VECTOR('',#32939,1.); +#32939 = DIRECTION('',(1.,0.)); +#32940 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32941 = PCURVE('',#30298,#32942); +#32942 = DEFINITIONAL_REPRESENTATION('',(#32943),#32947); +#32943 = LINE('',#32944,#32945); +#32944 = CARTESIAN_POINT('',(24.999999999825,-66.59999999963)); +#32945 = VECTOR('',#32946,1.); +#32946 = DIRECTION('',(1.791159811587E-12,-1.)); +#32947 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32948 = ORIENTED_EDGE('',*,*,#32949,.F.); +#32949 = EDGE_CURVE('',#31644,#32927,#32950,.T.); +#32950 = SURFACE_CURVE('',#32951,(#32955,#32962),.PCURVE_S1.); +#32951 = LINE('',#32952,#32953); +#32952 = CARTESIAN_POINT('',(-26.99999999982,66.600008269598,38.5)); +#32953 = VECTOR('',#32954,1.); +#32954 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#32955 = PCURVE('',#31659,#32956); +#32956 = DEFINITIONAL_REPRESENTATION('',(#32957),#32961); +#32957 = LINE('',#32958,#32959); +#32958 = CARTESIAN_POINT('',(0.,0.)); +#32959 = VECTOR('',#32960,1.); +#32960 = DIRECTION('',(-1.980689724944E-15,1.)); +#32961 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32962 = PCURVE('',#31687,#32963); +#32963 = DEFINITIONAL_REPRESENTATION('',(#32964),#32968); +#32964 = LINE('',#32965,#32966); +#32965 = CARTESIAN_POINT('',(50.00000000001,-3.553177122528E-25)); +#32966 = VECTOR('',#32967,1.); +#32967 = DIRECTION('',(7.106354245054E-27,1.)); +#32968 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32969 = ORIENTED_EDGE('',*,*,#31643,.T.); +#32970 = ADVANCED_FACE('',(#32971),#31517,.T.); +#32971 = FACE_BOUND('',#32972,.T.); +#32972 = EDGE_LOOP('',(#32973,#33003,#33024,#33025,#33048)); +#32973 = ORIENTED_EDGE('',*,*,#32974,.T.); +#32974 = EDGE_CURVE('',#32975,#32977,#32979,.T.); +#32975 = VERTEX_POINT('',#32976); +#32976 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,43.5)); +#32977 = VERTEX_POINT('',#32978); +#32978 = CARTESIAN_POINT('',(-36.80000000004,60.100008269669,43.5)); +#32979 = SURFACE_CURVE('',#32980,(#32985,#32992),.PCURVE_S1.); +#32980 = CIRCLE('',#32981,1.5); +#32981 = AXIS2_PLACEMENT_3D('',#32982,#32983,#32984); +#32982 = CARTESIAN_POINT('',(-35.30000000004,60.100008269745,43.5)); +#32983 = DIRECTION('',(-1.420970823333E-27,-1.980689724944E-15,-1.)); +#32984 = DIRECTION('',(-0.707106781169,-0.707106781204, + 1.400559135971E-15)); +#32985 = PCURVE('',#31517,#32986); +#32986 = DEFINITIONAL_REPRESENTATION('',(#32987),#32991); +#32987 = LINE('',#32988,#32989); +#32988 = CARTESIAN_POINT('',(6.28318530718,5.)); +#32989 = VECTOR('',#32990,1.); +#32990 = DIRECTION('',(-1.,0.)); +#32991 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#32992 = PCURVE('',#32835,#32993); +#32993 = DEFINITIONAL_REPRESENTATION('',(#32994),#33002); +#32994 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#32995,#32996,#32997,#32998 + ,#32999,#33000,#33001),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#32995 = CARTESIAN_POINT('',(4.460660171803,4.460660171901)); +#32996 = CARTESIAN_POINT('',(6.297777478936,2.62354286486)); +#32997 = CARTESIAN_POINT('',(3.78822856774,1.95111126067)); +#32998 = CARTESIAN_POINT('',(1.278679656544,1.278679656481)); +#32999 = CARTESIAN_POINT('',(1.951111260606,3.788228567711)); +#33000 = CARTESIAN_POINT('',(2.623542864669,6.297777478941)); +#33001 = CARTESIAN_POINT('',(4.460660171803,4.460660171901)); +#33002 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33003 = ORIENTED_EDGE('',*,*,#33004,.T.); +#33004 = EDGE_CURVE('',#32977,#31501,#33005,.T.); +#33005 = SURFACE_CURVE('',#33006,(#33010,#33017),.PCURVE_S1.); +#33006 = LINE('',#33007,#33008); +#33007 = CARTESIAN_POINT('',(-36.80000000004,60.100008269669,38.5)); +#33008 = VECTOR('',#33009,1.); +#33009 = DIRECTION('',(-8.978486131298E-26,7.171696191612E-87,-1.)); +#33010 = PCURVE('',#31517,#33011); +#33011 = DEFINITIONAL_REPRESENTATION('',(#33012),#33016); +#33012 = LINE('',#33013,#33014); +#33013 = CARTESIAN_POINT('',(-0.785398163372,0.)); +#33014 = VECTOR('',#33015,1.); +#33015 = DIRECTION('',(0.,-1.)); +#33016 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33017 = PCURVE('',#31545,#33018); +#33018 = DEFINITIONAL_REPRESENTATION('',(#33019),#33023); +#33019 = LINE('',#33020,#33021); +#33020 = CARTESIAN_POINT('',(1.500000000037,-2.97103458749E-15)); +#33021 = VECTOR('',#33022,1.); +#33022 = DIRECTION('',(-1.980689724944E-15,-1.)); +#33023 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33024 = ORIENTED_EDGE('',*,*,#31500,.T.); +#33025 = ORIENTED_EDGE('',*,*,#33026,.T.); +#33026 = EDGE_CURVE('',#31473,#33027,#33029,.T.); +#33027 = VERTEX_POINT('',#33028); +#33028 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,40.)); +#33029 = SURFACE_CURVE('',#33030,(#33034,#33041),.PCURVE_S1.); +#33030 = LINE('',#33031,#33032); +#33031 = CARTESIAN_POINT('',(-35.30000000004,58.600008269745,38.5)); +#33032 = VECTOR('',#33033,1.); +#33033 = DIRECTION('',(8.978486131298E-26,-7.171696191612E-87,1.)); +#33034 = PCURVE('',#31517,#33035); +#33035 = DEFINITIONAL_REPRESENTATION('',(#33036),#33040); +#33036 = LINE('',#33037,#33038); +#33037 = CARTESIAN_POINT('',(0.785398163372,0.)); +#33038 = VECTOR('',#33039,1.); +#33039 = DIRECTION('',(0.,1.)); +#33040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33041 = PCURVE('',#31488,#33042); +#33042 = DEFINITIONAL_REPRESENTATION('',(#33043),#33047); +#33043 = LINE('',#33044,#33045); +#33044 = CARTESIAN_POINT('',(-7.580958083508E-11,-1.077227547882E-37)); +#33045 = VECTOR('',#33046,1.); +#33046 = DIRECTION('',(8.836389639533E-26,1.)); +#33047 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33048 = ORIENTED_EDGE('',*,*,#33049,.T.); +#33049 = EDGE_CURVE('',#33027,#32975,#33050,.T.); +#33050 = SURFACE_CURVE('',#33051,(#33055,#33062),.PCURVE_S1.); +#33051 = LINE('',#33052,#33053); +#33052 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,38.5)); +#33053 = VECTOR('',#33054,1.); +#33054 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33055 = PCURVE('',#31517,#33056); +#33056 = DEFINITIONAL_REPRESENTATION('',(#33057),#33061); +#33057 = LINE('',#33058,#33059); +#33058 = CARTESIAN_POINT('',(0.785398163423,0.)); +#33059 = VECTOR('',#33060,1.); +#33060 = DIRECTION('',(0.,1.)); +#33061 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33062 = PCURVE('',#33063,#33068); +#33063 = PLANE('',#33064); +#33064 = AXIS2_PLACEMENT_3D('',#33065,#33066,#33067); +#33065 = CARTESIAN_POINT('',(-35.29999999997,58.600008269745,38.5)); +#33066 = DIRECTION('',(1.,5.054401341974E-11,-8.978420392889E-26)); +#33067 = DIRECTION('',(-5.054401341974E-11,1.,-1.980689724944E-15)); +#33068 = DEFINITIONAL_REPRESENTATION('',(#33069),#33073); +#33069 = LINE('',#33070,#33071); +#33070 = CARTESIAN_POINT('',(0.,0.)); +#33071 = VECTOR('',#33072,1.); +#33072 = DIRECTION('',(-2.043328855439E-16,1.)); +#33073 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33074 = ADVANCED_FACE('',(#33075),#31488,.T.); +#33075 = FACE_BOUND('',#33076,.T.); +#33076 = EDGE_LOOP('',(#33077,#33078,#33079,#33102)); +#33077 = ORIENTED_EDGE('',*,*,#33026,.F.); +#33078 = ORIENTED_EDGE('',*,*,#31472,.F.); +#33079 = ORIENTED_EDGE('',*,*,#33080,.T.); +#33080 = EDGE_CURVE('',#31445,#33081,#33083,.T.); +#33081 = VERTEX_POINT('',#33082); +#33082 = CARTESIAN_POINT('',(-34.99999999988,58.600008269745,40.)); +#33083 = SURFACE_CURVE('',#33084,(#33088,#33095),.PCURVE_S1.); +#33084 = LINE('',#33085,#33086); +#33085 = CARTESIAN_POINT('',(-34.99999999988,58.600008269745,38.5)); +#33086 = VECTOR('',#33087,1.); +#33087 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#33088 = PCURVE('',#31488,#33089); +#33089 = DEFINITIONAL_REPRESENTATION('',(#33090),#33094); +#33090 = LINE('',#33091,#33092); +#33091 = CARTESIAN_POINT('',(0.300000000086,4.262894754162E-28)); +#33092 = VECTOR('',#33093,1.); +#33093 = DIRECTION('',(-1.420964917647E-27,1.)); +#33094 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33095 = PCURVE('',#31460,#33096); +#33096 = DEFINITIONAL_REPRESENTATION('',(#33097),#33101); +#33097 = LINE('',#33098,#33099); +#33098 = CARTESIAN_POINT('',(0.,0.)); +#33099 = VECTOR('',#33100,1.); +#33100 = DIRECTION('',(1.980689724944E-15,1.)); +#33101 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33102 = ORIENTED_EDGE('',*,*,#33103,.F.); +#33103 = EDGE_CURVE('',#33027,#33081,#33104,.T.); +#33104 = SURFACE_CURVE('',#33105,(#33109,#33116),.PCURVE_S1.); +#33105 = LINE('',#33106,#33107); +#33106 = CARTESIAN_POINT('',(-34.99999999987,58.600008269745,40.)); +#33107 = VECTOR('',#33108,1.); +#33108 = DIRECTION('',(1.,3.595697235398E-72,-1.420964917647E-27)); +#33109 = PCURVE('',#31488,#33110); +#33110 = DEFINITIONAL_REPRESENTATION('',(#33111),#33115); +#33111 = LINE('',#33112,#33113); +#33112 = CARTESIAN_POINT('',(0.3000000001,1.5)); +#33113 = VECTOR('',#33114,1.); +#33114 = DIRECTION('',(1.,0.)); +#33115 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33116 = PCURVE('',#30298,#33117); +#33117 = DEFINITIONAL_REPRESENTATION('',(#33118),#33122); +#33118 = LINE('',#33119,#33120); +#33119 = CARTESIAN_POINT('',(32.999999999872,-58.59999999979)); +#33120 = VECTOR('',#33121,1.); +#33121 = DIRECTION('',(-1.,-8.723744686338E-59)); +#33122 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33123 = ADVANCED_FACE('',(#33124),#31545,.T.); +#33124 = FACE_BOUND('',#33125,.T.); +#33125 = EDGE_LOOP('',(#33126,#33127,#33150,#33171)); +#33126 = ORIENTED_EDGE('',*,*,#33004,.F.); +#33127 = ORIENTED_EDGE('',*,*,#33128,.F.); +#33128 = EDGE_CURVE('',#33129,#32977,#33131,.T.); +#33129 = VERTEX_POINT('',#33130); +#33130 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,43.5)); +#33131 = SURFACE_CURVE('',#33132,(#33136,#33143),.PCURVE_S1.); +#33132 = LINE('',#33133,#33134); +#33133 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,43.5)); +#33134 = VECTOR('',#33135,1.); +#33135 = DIRECTION('',(5.054438349408E-11,-1.,1.980689724944E-15)); +#33136 = PCURVE('',#31545,#33137); +#33137 = DEFINITIONAL_REPRESENTATION('',(#33138),#33142); +#33138 = LINE('',#33139,#33140); +#33139 = CARTESIAN_POINT('',(9.903448624721E-15,5.)); +#33140 = VECTOR('',#33141,1.); +#33141 = DIRECTION('',(1.,0.)); +#33142 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33143 = PCURVE('',#32835,#33144); +#33144 = DEFINITIONAL_REPRESENTATION('',(#33145),#33149); +#33145 = LINE('',#33146,#33147); +#33146 = CARTESIAN_POINT('',(4.900000000125,1.900000000133)); +#33147 = VECTOR('',#33148,1.); +#33148 = DIRECTION('',(-5.054438349408E-11,1.)); +#33149 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33150 = ORIENTED_EDGE('',*,*,#33151,.F.); +#33151 = EDGE_CURVE('',#31530,#33129,#33152,.T.); +#33152 = SURFACE_CURVE('',#33153,(#33157,#33164),.PCURVE_S1.); +#33153 = LINE('',#33154,#33155); +#33154 = CARTESIAN_POINT('',(-36.80000000012,61.600008269706,38.5)); +#33155 = VECTOR('',#33156,1.); +#33156 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33157 = PCURVE('',#31545,#33158); +#33158 = DEFINITIONAL_REPRESENTATION('',(#33159),#33163); +#33159 = LINE('',#33160,#33161); +#33160 = CARTESIAN_POINT('',(0.,0.)); +#33161 = VECTOR('',#33162,1.); +#33162 = DIRECTION('',(2.043328855439E-16,1.)); +#33163 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33164 = PCURVE('',#31574,#33165); +#33165 = DEFINITIONAL_REPRESENTATION('',(#33166),#33170); +#33166 = LINE('',#33167,#33168); +#33167 = CARTESIAN_POINT('',(1.570796326793,0.)); +#33168 = VECTOR('',#33169,1.); +#33169 = DIRECTION('',(0.,1.)); +#33170 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33171 = ORIENTED_EDGE('',*,*,#31529,.T.); +#33172 = ADVANCED_FACE('',(#33173),#32108,.F.); +#33173 = FACE_BOUND('',#33174,.T.); +#33174 = EDGE_LOOP('',(#33175,#33176,#33199,#33222)); +#33175 = ORIENTED_EDGE('',*,*,#32090,.F.); +#33176 = ORIENTED_EDGE('',*,*,#33177,.F.); +#33177 = EDGE_CURVE('',#33178,#32091,#33180,.T.); +#33178 = VERTEX_POINT('',#33179); +#33179 = CARTESIAN_POINT('',(21.000000000228,-56.59999173034,40.)); +#33180 = SURFACE_CURVE('',#33181,(#33185,#33192),.PCURVE_S1.); +#33181 = LINE('',#33182,#33183); +#33182 = CARTESIAN_POINT('',(21.000000000228,-56.59999173034,40.)); +#33183 = VECTOR('',#33184,1.); +#33184 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#33185 = PCURVE('',#32108,#33186); +#33186 = DEFINITIONAL_REPRESENTATION('',(#33187),#33191); +#33187 = LINE('',#33188,#33189); +#33188 = CARTESIAN_POINT('',(80.200000000059,3.772141652697E-14)); +#33189 = VECTOR('',#33190,1.); +#33190 = DIRECTION('',(-1.710690767248E-15,1.)); +#33191 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33192 = PCURVE('',#32190,#33193); +#33193 = DEFINITIONAL_REPRESENTATION('',(#33194),#33198); +#33194 = LINE('',#33195,#33196); +#33195 = CARTESIAN_POINT('',(-0.,0.)); +#33196 = VECTOR('',#33197,1.); +#33197 = DIRECTION('',(1.146036670579E-15,1.)); +#33198 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33199 = ORIENTED_EDGE('',*,*,#33200,.F.); +#33200 = EDGE_CURVE('',#33201,#33178,#33203,.T.); +#33201 = VERTEX_POINT('',#33202); +#33202 = CARTESIAN_POINT('',(21.000000000228,23.600008269715,40.)); +#33203 = SURFACE_CURVE('',#33204,(#33208,#33215),.PCURVE_S1.); +#33204 = LINE('',#33205,#33206); +#33205 = CARTESIAN_POINT('',(21.000000000228,11.800008269834,40.)); +#33206 = VECTOR('',#33207,1.); +#33207 = DIRECTION('',(-1.960514351287E-30,-1.,1.980689724944E-15)); +#33208 = PCURVE('',#32108,#33209); +#33209 = DEFINITIONAL_REPRESENTATION('',(#33210),#33214); +#33210 = LINE('',#33211,#33212); +#33211 = CARTESIAN_POINT('',(11.799999999881,1.196621340597E-13)); +#33212 = VECTOR('',#33213,1.); +#33213 = DIRECTION('',(1.,-2.699989576963E-16)); +#33214 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33215 = PCURVE('',#30298,#33216); +#33216 = DEFINITIONAL_REPRESENTATION('',(#33217),#33221); +#33217 = LINE('',#33218,#33219); +#33218 = CARTESIAN_POINT('',(-23.00000000022,-11.79999999988)); +#33219 = VECTOR('',#33220,1.); +#33220 = DIRECTION('',(1.96051435129E-30,1.)); +#33221 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33222 = ORIENTED_EDGE('',*,*,#33223,.T.); +#33223 = EDGE_CURVE('',#33201,#32093,#33224,.T.); +#33224 = SURFACE_CURVE('',#33225,(#33229,#33236),.PCURVE_S1.); +#33225 = LINE('',#33226,#33227); +#33226 = CARTESIAN_POINT('',(21.000000000228,23.600008269715,40.)); +#33227 = VECTOR('',#33228,1.); +#33228 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#33229 = PCURVE('',#32108,#33230); +#33230 = DEFINITIONAL_REPRESENTATION('',(#33231),#33235); +#33231 = LINE('',#33232,#33233); +#33232 = CARTESIAN_POINT('',(0.,-0.)); +#33233 = VECTOR('',#33234,1.); +#33234 = DIRECTION('',(-1.710690767248E-15,1.)); +#33235 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33236 = PCURVE('',#32136,#33237); +#33237 = DEFINITIONAL_REPRESENTATION('',(#33238),#33242); +#33238 = LINE('',#33239,#33240); +#33239 = CARTESIAN_POINT('',(36.000000000043,-5.821866286552E-14)); +#33240 = VECTOR('',#33241,1.); +#33241 = DIRECTION('',(-1.146036670579E-15,1.)); +#33242 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33243 = ADVANCED_FACE('',(#33244),#32136,.F.); +#33244 = FACE_BOUND('',#33245,.T.); +#33245 = EDGE_LOOP('',(#33246,#33247,#33248,#33271)); +#33246 = ORIENTED_EDGE('',*,*,#32120,.F.); +#33247 = ORIENTED_EDGE('',*,*,#33223,.F.); +#33248 = ORIENTED_EDGE('',*,*,#33249,.F.); +#33249 = EDGE_CURVE('',#33250,#33201,#33252,.T.); +#33250 = VERTEX_POINT('',#33251); +#33251 = CARTESIAN_POINT('',(-14.99999999981,23.600008269715,40.)); +#33252 = SURFACE_CURVE('',#33253,(#33257,#33264),.PCURVE_S1.); +#33253 = LINE('',#33254,#33255); +#33254 = CARTESIAN_POINT('',(-8.499999999907,23.600008269715,40.)); +#33255 = VECTOR('',#33256,1.); +#33256 = DIRECTION('',(1.,-2.467162276942E-16,-1.42047624935E-27)); +#33257 = PCURVE('',#32136,#33258); +#33258 = DEFINITIONAL_REPRESENTATION('',(#33259),#33263); +#33259 = LINE('',#33260,#33261); +#33260 = CARTESIAN_POINT('',(6.499999999909,7.449238358659E-15)); +#33261 = VECTOR('',#33262,1.); +#33262 = DIRECTION('',(1.,1.14603667058E-15)); +#33263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33264 = PCURVE('',#30298,#33265); +#33265 = DEFINITIONAL_REPRESENTATION('',(#33266),#33270); +#33266 = LINE('',#33267,#33268); +#33267 = CARTESIAN_POINT('',(6.499999999908,-23.59999999976)); +#33268 = VECTOR('',#33269,1.); +#33269 = DIRECTION('',(-1.,2.467162276942E-16)); +#33270 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33271 = ORIENTED_EDGE('',*,*,#33272,.T.); +#33272 = EDGE_CURVE('',#33250,#32121,#33273,.T.); +#33273 = SURFACE_CURVE('',#33274,(#33278,#33285),.PCURVE_S1.); +#33274 = LINE('',#33275,#33276); +#33275 = CARTESIAN_POINT('',(-14.99999999981,23.600008269715,40.)); +#33276 = VECTOR('',#33277,1.); +#33277 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#33278 = PCURVE('',#32136,#33279); +#33279 = DEFINITIONAL_REPRESENTATION('',(#33280),#33284); +#33280 = LINE('',#33281,#33282); +#33281 = CARTESIAN_POINT('',(0.,0.)); +#33282 = VECTOR('',#33283,1.); +#33283 = DIRECTION('',(-1.146036670579E-15,1.)); +#33284 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33285 = PCURVE('',#32164,#33286); +#33286 = DEFINITIONAL_REPRESENTATION('',(#33287),#33291); +#33287 = LINE('',#33288,#33289); +#33288 = CARTESIAN_POINT('',(80.200000000059,6.175456647945E-14)); +#33289 = VECTOR('',#33290,1.); +#33290 = DIRECTION('',(1.710690767248E-15,1.)); +#33291 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33292 = ADVANCED_FACE('',(#33293),#32164,.F.); +#33293 = FACE_BOUND('',#33294,.T.); +#33294 = EDGE_LOOP('',(#33295,#33296,#33297,#33320)); +#33295 = ORIENTED_EDGE('',*,*,#32148,.F.); +#33296 = ORIENTED_EDGE('',*,*,#33272,.F.); +#33297 = ORIENTED_EDGE('',*,*,#33298,.F.); +#33298 = EDGE_CURVE('',#33299,#33250,#33301,.T.); +#33299 = VERTEX_POINT('',#33300); +#33300 = CARTESIAN_POINT('',(-14.99999999981,-56.59999173034,40.)); +#33301 = SURFACE_CURVE('',#33302,(#33306,#33313),.PCURVE_S1.); +#33302 = LINE('',#33303,#33304); +#33303 = CARTESIAN_POINT('',(-14.99999999981,-28.29999173019,40.)); +#33304 = VECTOR('',#33305,1.); +#33305 = DIRECTION('',(1.960514351287E-30,1.,-1.980689724944E-15)); +#33306 = PCURVE('',#32164,#33307); +#33307 = DEFINITIONAL_REPRESENTATION('',(#33308),#33312); +#33308 = LINE('',#33309,#33310); +#33309 = CARTESIAN_POINT('',(28.300000000149,5.106343429304E-14)); +#33310 = VECTOR('',#33311,1.); +#33311 = DIRECTION('',(1.,2.699989576963E-16)); +#33312 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33313 = PCURVE('',#30298,#33314); +#33314 = DEFINITIONAL_REPRESENTATION('',(#33315),#33319); +#33315 = LINE('',#33316,#33317); +#33316 = CARTESIAN_POINT('',(12.999999999817,28.300000000148)); +#33317 = VECTOR('',#33318,1.); +#33318 = DIRECTION('',(-1.96051435129E-30,-1.)); +#33319 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33320 = ORIENTED_EDGE('',*,*,#33321,.T.); +#33321 = EDGE_CURVE('',#33299,#32149,#33322,.T.); +#33322 = SURFACE_CURVE('',#33323,(#33327,#33334),.PCURVE_S1.); +#33323 = LINE('',#33324,#33325); +#33324 = CARTESIAN_POINT('',(-14.99999999981,-56.59999173034,40.)); +#33325 = VECTOR('',#33326,1.); +#33326 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#33327 = PCURVE('',#32164,#33328); +#33328 = DEFINITIONAL_REPRESENTATION('',(#33329),#33333); +#33329 = LINE('',#33330,#33331); +#33330 = CARTESIAN_POINT('',(0.,-0.)); +#33331 = VECTOR('',#33332,1.); +#33332 = DIRECTION('',(1.710690767248E-15,1.)); +#33333 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33334 = PCURVE('',#32190,#33335); +#33335 = DEFINITIONAL_REPRESENTATION('',(#33336),#33340); +#33336 = LINE('',#33337,#33338); +#33337 = CARTESIAN_POINT('',(36.000000000043,-4.12573201409E-14)); +#33338 = VECTOR('',#33339,1.); +#33339 = DIRECTION('',(1.146036670579E-15,1.)); +#33340 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33341 = ADVANCED_FACE('',(#33342),#32190,.F.); +#33342 = FACE_BOUND('',#33343,.T.); +#33343 = EDGE_LOOP('',(#33344,#33345,#33346,#33367)); +#33344 = ORIENTED_EDGE('',*,*,#32176,.F.); +#33345 = ORIENTED_EDGE('',*,*,#33321,.F.); +#33346 = ORIENTED_EDGE('',*,*,#33347,.F.); +#33347 = EDGE_CURVE('',#33178,#33299,#33348,.T.); +#33348 = SURFACE_CURVE('',#33349,(#33353,#33360),.PCURVE_S1.); +#33349 = LINE('',#33350,#33351); +#33350 = CARTESIAN_POINT('',(9.500000000115,-56.59999173034,40.)); +#33351 = VECTOR('',#33352,1.); +#33352 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#33353 = PCURVE('',#32190,#33354); +#33354 = DEFINITIONAL_REPRESENTATION('',(#33355),#33359); +#33355 = LINE('',#33356,#33357); +#33356 = CARTESIAN_POINT('',(11.500000000113,8.629656129463E-14)); +#33357 = VECTOR('',#33358,1.); +#33358 = DIRECTION('',(1.,-1.14603667058E-15)); +#33359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33360 = PCURVE('',#30298,#33361); +#33361 = DEFINITIONAL_REPRESENTATION('',(#33362),#33366); +#33362 = LINE('',#33363,#33364); +#33363 = CARTESIAN_POINT('',(-11.50000000011,56.600000000297)); +#33364 = VECTOR('',#33365,1.); +#33365 = DIRECTION('',(1.,8.723744686338E-59)); +#33366 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33367 = ORIENTED_EDGE('',*,*,#33177,.T.); +#33368 = ADVANCED_FACE('',(#33369),#33063,.T.); +#33369 = FACE_BOUND('',#33370,.T.); +#33370 = EDGE_LOOP('',(#33371,#33394,#33422,#33443)); +#33371 = ORIENTED_EDGE('',*,*,#33372,.F.); +#33372 = EDGE_CURVE('',#33373,#33027,#33375,.T.); +#33373 = VERTEX_POINT('',#33374); +#33374 = CARTESIAN_POINT('',(-35.30000000012,61.600008269706,40.)); +#33375 = SURFACE_CURVE('',#33376,(#33380,#33387),.PCURVE_S1.); +#33376 = LINE('',#33377,#33378); +#33377 = CARTESIAN_POINT('',(-35.30000000012,61.600008269706,40.)); +#33378 = VECTOR('',#33379,1.); +#33379 = DIRECTION('',(5.054401341974E-11,-1.,1.980689724944E-15)); +#33380 = PCURVE('',#33063,#33381); +#33381 = DEFINITIONAL_REPRESENTATION('',(#33382),#33386); +#33382 = LINE('',#33383,#33384); +#33383 = CARTESIAN_POINT('',(2.999999999961,1.5)); +#33384 = VECTOR('',#33385,1.); +#33385 = DIRECTION('',(-1.,0.)); +#33386 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33387 = PCURVE('',#30298,#33388); +#33388 = DEFINITIONAL_REPRESENTATION('',(#33389),#33393); +#33389 = LINE('',#33390,#33391); +#33390 = CARTESIAN_POINT('',(33.300000000123,-61.59999999975)); +#33391 = VECTOR('',#33392,1.); +#33392 = DIRECTION('',(-5.054401341974E-11,1.)); +#33393 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33394 = ORIENTED_EDGE('',*,*,#33395,.T.); +#33395 = EDGE_CURVE('',#33373,#33396,#33398,.T.); +#33396 = VERTEX_POINT('',#33397); +#33397 = CARTESIAN_POINT('',(-35.30000000012,61.600008269706,43.5)); +#33398 = SURFACE_CURVE('',#33399,(#33403,#33410),.PCURVE_S1.); +#33399 = LINE('',#33400,#33401); +#33400 = CARTESIAN_POINT('',(-35.30000000012,61.600008269706,38.5)); +#33401 = VECTOR('',#33402,1.); +#33402 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33403 = PCURVE('',#33063,#33404); +#33404 = DEFINITIONAL_REPRESENTATION('',(#33405),#33409); +#33405 = LINE('',#33406,#33407); +#33406 = CARTESIAN_POINT('',(2.999999999961,5.942069174756E-15)); +#33407 = VECTOR('',#33408,1.); +#33408 = DIRECTION('',(-2.043328855439E-16,1.)); +#33409 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33410 = PCURVE('',#33411,#33416); +#33411 = CYLINDRICAL_SURFACE('',#33412,5.300000000227); +#33412 = AXIS2_PLACEMENT_3D('',#33413,#33414,#33415); +#33413 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,38.5)); +#33414 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33415 = DIRECTION('',(-1.83249641868E-12,1.,-1.7763568394E-15)); +#33416 = DEFINITIONAL_REPRESENTATION('',(#33417),#33421); +#33417 = LINE('',#33418,#33419); +#33418 = CARTESIAN_POINT('',(1.570796326793,0.)); +#33419 = VECTOR('',#33420,1.); +#33420 = DIRECTION('',(0.,1.)); +#33421 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33422 = ORIENTED_EDGE('',*,*,#33423,.F.); +#33423 = EDGE_CURVE('',#32975,#33396,#33424,.T.); +#33424 = SURFACE_CURVE('',#33425,(#33429,#33436),.PCURVE_S1.); +#33425 = LINE('',#33426,#33427); +#33426 = CARTESIAN_POINT('',(-35.30000000012,61.600008269706,43.5)); +#33427 = VECTOR('',#33428,1.); +#33428 = DIRECTION('',(-5.054401341974E-11,1.,-1.980689724944E-15)); +#33429 = PCURVE('',#33063,#33430); +#33430 = DEFINITIONAL_REPRESENTATION('',(#33431),#33435); +#33431 = LINE('',#33432,#33433); +#33432 = CARTESIAN_POINT('',(2.999999999961,5.)); +#33433 = VECTOR('',#33434,1.); +#33434 = DIRECTION('',(1.,0.)); +#33435 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33436 = PCURVE('',#32835,#33437); +#33437 = DEFINITIONAL_REPRESENTATION('',(#33438),#33442); +#33438 = LINE('',#33439,#33440); +#33439 = CARTESIAN_POINT('',(3.400000000125,1.900000000133)); +#33440 = VECTOR('',#33441,1.); +#33441 = DIRECTION('',(5.054401341974E-11,-1.)); +#33442 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33443 = ORIENTED_EDGE('',*,*,#33049,.F.); +#33444 = ADVANCED_FACE('',(#33445),#33411,.F.); +#33445 = FACE_BOUND('',#33446,.F.); +#33446 = EDGE_LOOP('',(#33447,#33448,#33476,#33499)); +#33447 = ORIENTED_EDGE('',*,*,#33395,.T.); +#33448 = ORIENTED_EDGE('',*,*,#33449,.T.); +#33449 = EDGE_CURVE('',#33396,#33450,#33452,.T.); +#33450 = VERTEX_POINT('',#33451); +#33451 = CARTESIAN_POINT('',(-29.99999999995,66.900008269933,43.5)); +#33452 = SURFACE_CURVE('',#33453,(#33458,#33465),.PCURVE_S1.); +#33453 = CIRCLE('',#33454,5.300000000227); +#33454 = AXIS2_PLACEMENT_3D('',#33455,#33456,#33457); +#33455 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,43.5)); +#33456 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#33457 = DIRECTION('',(-1.83249641868E-12,1.,-1.980689724944E-15)); +#33458 = PCURVE('',#33411,#33459); +#33459 = DEFINITIONAL_REPRESENTATION('',(#33460),#33464); +#33460 = LINE('',#33461,#33462); +#33461 = CARTESIAN_POINT('',(6.28318530718,5.)); +#33462 = VECTOR('',#33463,1.); +#33463 = DIRECTION('',(-1.,4.523455546976E-15)); +#33464 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33465 = PCURVE('',#32835,#33466); +#33466 = DEFINITIONAL_REPRESENTATION('',(#33467),#33475); +#33467 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#33468,#33469,#33470,#33471 + ,#33472,#33473,#33474),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#33468 = CARTESIAN_POINT('',(-1.900000000045,-3.400000000094)); +#33469 = CARTESIAN_POINT('',(-11.07986928055,-3.400000000111)); +#33470 = CARTESIAN_POINT('',(-6.489934640314,4.550000000238)); +#33471 = CARTESIAN_POINT('',(-1.900000000074,12.500000000586)); +#33472 = CARTESIAN_POINT('',(2.689934640194,4.550000000254)); +#33473 = CARTESIAN_POINT('',(7.279869280463,-3.400000000077)); +#33474 = CARTESIAN_POINT('',(-1.900000000045,-3.400000000094)); +#33475 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33476 = ORIENTED_EDGE('',*,*,#33477,.F.); +#33477 = EDGE_CURVE('',#33478,#33450,#33480,.T.); +#33478 = VERTEX_POINT('',#33479); +#33479 = CARTESIAN_POINT('',(-29.99999999995,66.900008269933,40.)); +#33480 = SURFACE_CURVE('',#33481,(#33485,#33492),.PCURVE_S1.); +#33481 = LINE('',#33482,#33483); +#33482 = CARTESIAN_POINT('',(-29.99999999995,66.900008269933,38.5)); +#33483 = VECTOR('',#33484,1.); +#33484 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33485 = PCURVE('',#33411,#33486); +#33486 = DEFINITIONAL_REPRESENTATION('',(#33487),#33491); +#33487 = LINE('',#33488,#33489); +#33488 = CARTESIAN_POINT('',(0.,1.42108547152E-14)); +#33489 = VECTOR('',#33490,1.); +#33490 = DIRECTION('',(0.,1.)); +#33491 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33492 = PCURVE('',#32867,#33493); +#33493 = DEFINITIONAL_REPRESENTATION('',(#33494),#33498); +#33494 = LINE('',#33495,#33496); +#33495 = CARTESIAN_POINT('',(0.,0.)); +#33496 = VECTOR('',#33497,1.); +#33497 = DIRECTION('',(5.371983424479E-27,1.)); +#33498 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33499 = ORIENTED_EDGE('',*,*,#33500,.T.); +#33500 = EDGE_CURVE('',#33478,#33373,#33501,.T.); +#33501 = SURFACE_CURVE('',#33502,(#33507,#33514),.PCURVE_S1.); +#33502 = CIRCLE('',#33503,5.300000000227); +#33503 = AXIS2_PLACEMENT_3D('',#33504,#33505,#33506); +#33504 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,40.)); +#33505 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#33506 = DIRECTION('',(-1.83249641868E-12,1.,-1.980689724944E-15)); +#33507 = PCURVE('',#33411,#33508); +#33508 = DEFINITIONAL_REPRESENTATION('',(#33509),#33513); +#33509 = LINE('',#33510,#33511); +#33510 = CARTESIAN_POINT('',(0.,1.5)); +#33511 = VECTOR('',#33512,1.); +#33512 = DIRECTION('',(1.,-4.523455546976E-15)); +#33513 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33514 = PCURVE('',#30298,#33515); +#33515 = DEFINITIONAL_REPRESENTATION('',(#33516),#33520); +#33516 = CIRCLE('',#33517,5.300000000227); +#33517 = AXIS2_PLACEMENT_2D('',#33518,#33519); +#33518 = CARTESIAN_POINT('',(27.999999999943,-61.59999999975)); +#33519 = DIRECTION('',(1.83249641868E-12,-1.)); +#33520 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33521 = ADVANCED_FACE('',(#33522),#32867,.T.); +#33522 = FACE_BOUND('',#33523,.T.); +#33523 = EDGE_LOOP('',(#33524,#33545,#33546,#33567)); +#33524 = ORIENTED_EDGE('',*,*,#33525,.F.); +#33525 = EDGE_CURVE('',#32852,#33478,#33526,.T.); +#33526 = SURFACE_CURVE('',#33527,(#33531,#33538),.PCURVE_S1.); +#33527 = LINE('',#33528,#33529); +#33528 = CARTESIAN_POINT('',(-26.99999999982,66.900008269833,40.)); +#33529 = VECTOR('',#33530,1.); +#33530 = DIRECTION('',(-1.,3.324451824797E-11,-6.442611078683E-26)); +#33531 = PCURVE('',#32867,#33532); +#33532 = DEFINITIONAL_REPRESENTATION('',(#33533),#33537); +#33533 = LINE('',#33534,#33535); +#33534 = CARTESIAN_POINT('',(3.000000000127,1.5)); +#33535 = VECTOR('',#33536,1.); +#33536 = DIRECTION('',(-1.,0.)); +#33537 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33538 = PCURVE('',#30298,#33539); +#33539 = DEFINITIONAL_REPRESENTATION('',(#33540),#33544); +#33540 = LINE('',#33541,#33542); +#33541 = CARTESIAN_POINT('',(24.999999999826,-66.89999999988)); +#33542 = VECTOR('',#33543,1.); +#33543 = DIRECTION('',(1.,-3.324451824797E-11)); +#33544 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33545 = ORIENTED_EDGE('',*,*,#32851,.T.); +#33546 = ORIENTED_EDGE('',*,*,#33547,.F.); +#33547 = EDGE_CURVE('',#33450,#32819,#33548,.T.); +#33548 = SURFACE_CURVE('',#33549,(#33553,#33560),.PCURVE_S1.); +#33549 = LINE('',#33550,#33551); +#33550 = CARTESIAN_POINT('',(-26.99999999982,66.900008269833,43.5)); +#33551 = VECTOR('',#33552,1.); +#33552 = DIRECTION('',(1.,-3.324451824797E-11,6.442611078683E-26)); +#33553 = PCURVE('',#32867,#33554); +#33554 = DEFINITIONAL_REPRESENTATION('',(#33555),#33559); +#33555 = LINE('',#33556,#33557); +#33556 = CARTESIAN_POINT('',(3.000000000127,5.)); +#33557 = VECTOR('',#33558,1.); +#33558 = DIRECTION('',(1.,0.)); +#33559 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33560 = PCURVE('',#32835,#33561); +#33561 = DEFINITIONAL_REPRESENTATION('',(#33562),#33566); +#33562 = LINE('',#33563,#33564); +#33563 = CARTESIAN_POINT('',(-4.900000000172,-3.399999999994)); +#33564 = VECTOR('',#33565,1.); +#33565 = DIRECTION('',(-1.,3.324451824797E-11)); +#33566 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33567 = ORIENTED_EDGE('',*,*,#33477,.F.); +#33568 = ADVANCED_FACE('',(#33569),#31574,.T.); +#33569 = FACE_BOUND('',#33570,.T.); +#33570 = EDGE_LOOP('',(#33571,#33572,#33573,#33597)); +#33571 = ORIENTED_EDGE('',*,*,#31557,.T.); +#33572 = ORIENTED_EDGE('',*,*,#33151,.T.); +#33573 = ORIENTED_EDGE('',*,*,#33574,.F.); +#33574 = EDGE_CURVE('',#33575,#33129,#33577,.T.); +#33575 = VERTEX_POINT('',#33576); +#33576 = CARTESIAN_POINT('',(-29.99999999995,68.400008269933,43.5)); +#33577 = SURFACE_CURVE('',#33578,(#33583,#33590),.PCURVE_S1.); +#33578 = CIRCLE('',#33579,6.800000000227); +#33579 = AXIS2_PLACEMENT_3D('',#33580,#33581,#33582); +#33580 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,43.5)); +#33581 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#33582 = DIRECTION('',(-1.832521062938E-12,1.,-1.980689724944E-15)); +#33583 = PCURVE('',#31574,#33584); +#33584 = DEFINITIONAL_REPRESENTATION('',(#33585),#33589); +#33585 = LINE('',#33586,#33587); +#33586 = CARTESIAN_POINT('',(0.,5.)); +#33587 = VECTOR('',#33588,1.); +#33588 = DIRECTION('',(1.,0.)); +#33589 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33590 = PCURVE('',#32835,#33591); +#33591 = DEFINITIONAL_REPRESENTATION('',(#33592),#33596); +#33592 = CIRCLE('',#33593,6.800000000227); +#33593 = AXIS2_PLACEMENT_2D('',#33594,#33595); +#33594 = CARTESIAN_POINT('',(-1.900000000055,1.900000000133)); +#33595 = DIRECTION('',(1.832521062938E-12,-1.)); +#33596 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33597 = ORIENTED_EDGE('',*,*,#33598,.F.); +#33598 = EDGE_CURVE('',#31558,#33575,#33599,.T.); +#33599 = SURFACE_CURVE('',#33600,(#33604,#33611),.PCURVE_S1.); +#33600 = LINE('',#33601,#33602); +#33601 = CARTESIAN_POINT('',(-29.99999999995,68.400008269933,38.5)); +#33602 = VECTOR('',#33603,1.); +#33603 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33604 = PCURVE('',#31574,#33605); +#33605 = DEFINITIONAL_REPRESENTATION('',(#33606),#33610); +#33606 = LINE('',#33607,#33608); +#33607 = CARTESIAN_POINT('',(0.,1.42108547152E-14)); +#33608 = VECTOR('',#33609,1.); +#33609 = DIRECTION('',(0.,1.)); +#33610 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33611 = PCURVE('',#31602,#33612); +#33612 = DEFINITIONAL_REPRESENTATION('',(#33613),#33617); +#33613 = LINE('',#33614,#33615); +#33614 = CARTESIAN_POINT('',(3.000000000127,1.93275176925E-25)); +#33615 = VECTOR('',#33616,1.); +#33616 = DIRECTION('',(-5.371983424479E-27,1.)); +#33617 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33618 = ADVANCED_FACE('',(#33619),#31602,.T.); +#33619 = FACE_BOUND('',#33620,.T.); +#33620 = EDGE_LOOP('',(#33621,#33622,#33623,#33624)); +#33621 = ORIENTED_EDGE('',*,*,#32901,.F.); +#33622 = ORIENTED_EDGE('',*,*,#31586,.T.); +#33623 = ORIENTED_EDGE('',*,*,#33598,.T.); +#33624 = ORIENTED_EDGE('',*,*,#33625,.F.); +#33625 = EDGE_CURVE('',#32817,#33575,#33626,.T.); +#33626 = SURFACE_CURVE('',#33627,(#33631,#33638),.PCURVE_S1.); +#33627 = LINE('',#33628,#33629); +#33628 = CARTESIAN_POINT('',(-26.99999999982,68.400008269833,43.5)); +#33629 = VECTOR('',#33630,1.); +#33630 = DIRECTION('',(-1.,3.324451824797E-11,-6.442611078683E-26)); +#33631 = PCURVE('',#31602,#33632); +#33632 = DEFINITIONAL_REPRESENTATION('',(#33633),#33637); +#33633 = LINE('',#33634,#33635); +#33634 = CARTESIAN_POINT('',(1.503024649647E-25,5.)); +#33635 = VECTOR('',#33636,1.); +#33636 = DIRECTION('',(1.,0.)); +#33637 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33638 = PCURVE('',#32835,#33639); +#33639 = DEFINITIONAL_REPRESENTATION('',(#33640),#33644); +#33640 = LINE('',#33641,#33642); +#33641 = CARTESIAN_POINT('',(-4.900000000169,-4.899999999994)); +#33642 = VECTOR('',#33643,1.); +#33643 = DIRECTION('',(1.,-3.324451824797E-11)); +#33644 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33645 = ADVANCED_FACE('',(#33646),#32835,.T.); +#33646 = FACE_BOUND('',#33647,.T.); +#33647 = EDGE_LOOP('',(#33648,#33649,#33650,#33651,#33652,#33653,#33654, + #33655)); +#33648 = ORIENTED_EDGE('',*,*,#32816,.F.); +#33649 = ORIENTED_EDGE('',*,*,#33625,.T.); +#33650 = ORIENTED_EDGE('',*,*,#33574,.T.); +#33651 = ORIENTED_EDGE('',*,*,#33128,.T.); +#33652 = ORIENTED_EDGE('',*,*,#32974,.F.); +#33653 = ORIENTED_EDGE('',*,*,#33423,.T.); +#33654 = ORIENTED_EDGE('',*,*,#33449,.T.); +#33655 = ORIENTED_EDGE('',*,*,#33547,.T.); +#33656 = ADVANCED_FACE('',(#33657),#30840,.T.); +#33657 = FACE_BOUND('',#33658,.T.); +#33658 = EDGE_LOOP('',(#33659,#33682,#33703,#33704)); +#33659 = ORIENTED_EDGE('',*,*,#33660,.F.); +#33660 = EDGE_CURVE('',#33661,#32229,#33663,.T.); +#33661 = VERTEX_POINT('',#33662); +#33662 = CARTESIAN_POINT('',(-30.00000000003,-66.89999173012,40.)); +#33663 = SURFACE_CURVE('',#33664,(#33668,#33675),.PCURVE_S1.); +#33664 = LINE('',#33665,#33666); +#33665 = CARTESIAN_POINT('',(-30.00000000003,-66.89999173012,40.)); +#33666 = VECTOR('',#33667,1.); +#33667 = DIRECTION('',(1.,3.253989670185E-11,-6.587240396574E-26)); +#33668 = PCURVE('',#30840,#33669); +#33669 = DEFINITIONAL_REPRESENTATION('',(#33670),#33674); +#33670 = LINE('',#33671,#33672); +#33671 = CARTESIAN_POINT('',(3.000000000114,1.5)); +#33672 = VECTOR('',#33673,1.); +#33673 = DIRECTION('',(-1.,0.)); +#33674 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33675 = PCURVE('',#30298,#33676); +#33676 = DEFINITIONAL_REPRESENTATION('',(#33677),#33681); +#33677 = LINE('',#33678,#33679); +#33678 = CARTESIAN_POINT('',(28.000000000031,66.900000000074)); +#33679 = VECTOR('',#33680,1.); +#33680 = DIRECTION('',(-1.,-3.253989670185E-11)); +#33681 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33682 = ORIENTED_EDGE('',*,*,#33683,.T.); +#33683 = EDGE_CURVE('',#33661,#30825,#33684,.T.); +#33684 = SURFACE_CURVE('',#33685,(#33689,#33696),.PCURVE_S1.); +#33685 = LINE('',#33686,#33687); +#33686 = CARTESIAN_POINT('',(-30.00000000003,-66.89999173012,38.5)); +#33687 = VECTOR('',#33688,1.); +#33688 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33689 = PCURVE('',#30840,#33690); +#33690 = DEFINITIONAL_REPRESENTATION('',(#33691),#33695); +#33691 = LINE('',#33692,#33693); +#33692 = CARTESIAN_POINT('',(3.000000000114,-1.976077455738E-25)); +#33693 = VECTOR('',#33694,1.); +#33694 = DIRECTION('',(8.069935906037E-27,1.)); +#33695 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33696 = PCURVE('',#30873,#33697); +#33697 = DEFINITIONAL_REPRESENTATION('',(#33698),#33702); +#33698 = LINE('',#33699,#33700); +#33699 = CARTESIAN_POINT('',(1.570796326795,-1.42108547152E-14)); +#33700 = VECTOR('',#33701,1.); +#33701 = DIRECTION('',(0.,1.)); +#33702 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33703 = ORIENTED_EDGE('',*,*,#30824,.F.); +#33704 = ORIENTED_EDGE('',*,*,#32251,.F.); +#33705 = ADVANCED_FACE('',(#33706),#30873,.F.); +#33706 = FACE_BOUND('',#33707,.F.); +#33707 = EDGE_LOOP('',(#33708,#33709,#33710,#33733)); +#33708 = ORIENTED_EDGE('',*,*,#33683,.T.); +#33709 = ORIENTED_EDGE('',*,*,#30852,.T.); +#33710 = ORIENTED_EDGE('',*,*,#33711,.F.); +#33711 = EDGE_CURVE('',#33712,#30853,#33714,.T.); +#33712 = VERTEX_POINT('',#33713); +#33713 = CARTESIAN_POINT('',(-35.29999999984,-61.59999173032,40.)); +#33714 = SURFACE_CURVE('',#33715,(#33719,#33726),.PCURVE_S1.); +#33715 = LINE('',#33716,#33717); +#33716 = CARTESIAN_POINT('',(-35.29999999984,-61.59999173032,38.5)); +#33717 = VECTOR('',#33718,1.); +#33718 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33719 = PCURVE('',#30873,#33720); +#33720 = DEFINITIONAL_REPRESENTATION('',(#33721),#33725); +#33721 = LINE('',#33722,#33723); +#33722 = CARTESIAN_POINT('',(0.,0.)); +#33723 = VECTOR('',#33724,1.); +#33724 = DIRECTION('',(0.,1.)); +#33725 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33726 = PCURVE('',#30617,#33727); +#33727 = DEFINITIONAL_REPRESENTATION('',(#33728),#33732); +#33728 = LINE('',#33729,#33730); +#33729 = CARTESIAN_POINT('',(0.,0.)); +#33730 = VECTOR('',#33731,1.); +#33731 = DIRECTION('',(-2.043328855439E-16,1.)); +#33732 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33733 = ORIENTED_EDGE('',*,*,#33734,.T.); +#33734 = EDGE_CURVE('',#33712,#33661,#33735,.T.); +#33735 = SURFACE_CURVE('',#33736,(#33741,#33748),.PCURVE_S1.); +#33736 = CIRCLE('',#33737,5.29999999981); +#33737 = AXIS2_PLACEMENT_3D('',#33738,#33739,#33740); +#33738 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,40.)); +#33739 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#33740 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#33741 = PCURVE('',#30873,#33742); +#33742 = DEFINITIONAL_REPRESENTATION('',(#33743),#33747); +#33743 = LINE('',#33744,#33745); +#33744 = CARTESIAN_POINT('',(0.,1.5)); +#33745 = VECTOR('',#33746,1.); +#33746 = DIRECTION('',(1.,-4.52345554697E-15)); +#33747 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33748 = PCURVE('',#30298,#33749); +#33749 = DEFINITIONAL_REPRESENTATION('',(#33750),#33754); +#33750 = CIRCLE('',#33751,5.29999999981); +#33751 = AXIS2_PLACEMENT_2D('',#33752,#33753); +#33752 = CARTESIAN_POINT('',(28.000000000031,61.60000000028)); +#33753 = DIRECTION('',(1.,8.723744686338E-59)); +#33754 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33755 = ADVANCED_FACE('',(#33756),#30617,.T.); +#33756 = FACE_BOUND('',#33757,.T.); +#33757 = EDGE_LOOP('',(#33758,#33779,#33780,#33781)); +#33758 = ORIENTED_EDGE('',*,*,#33759,.F.); +#33759 = EDGE_CURVE('',#30602,#33712,#33760,.T.); +#33760 = SURFACE_CURVE('',#33761,(#33765,#33772),.PCURVE_S1.); +#33761 = LINE('',#33762,#33763); +#33762 = CARTESIAN_POINT('',(-35.29999999975,-58.59999173031,40.)); +#33763 = VECTOR('',#33764,1.); +#33764 = DIRECTION('',(-2.72026845493E-11,-1.,1.980689724944E-15)); +#33765 = PCURVE('',#30617,#33766); +#33766 = DEFINITIONAL_REPRESENTATION('',(#33767),#33771); +#33767 = LINE('',#33768,#33769); +#33768 = CARTESIAN_POINT('',(3.000000000008,1.5)); +#33769 = VECTOR('',#33770,1.); +#33770 = DIRECTION('',(-1.,0.)); +#33771 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33772 = PCURVE('',#30298,#33773); +#33773 = DEFINITIONAL_REPRESENTATION('',(#33774),#33778); +#33774 = LINE('',#33775,#33776); +#33775 = CARTESIAN_POINT('',(33.29999999976,58.600000000272)); +#33776 = VECTOR('',#33777,1.); +#33777 = DIRECTION('',(2.72026845493E-11,1.)); +#33778 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33779 = ORIENTED_EDGE('',*,*,#30601,.T.); +#33780 = ORIENTED_EDGE('',*,*,#30885,.F.); +#33781 = ORIENTED_EDGE('',*,*,#33711,.F.); +#33782 = ADVANCED_FACE('',(#33783),#30751,.T.); +#33783 = FACE_BOUND('',#33784,.T.); +#33784 = EDGE_LOOP('',(#33785,#33786,#33787,#33788)); +#33785 = ORIENTED_EDGE('',*,*,#31285,.T.); +#33786 = ORIENTED_EDGE('',*,*,#32277,.T.); +#33787 = ORIENTED_EDGE('',*,*,#30734,.F.); +#33788 = ORIENTED_EDGE('',*,*,#30933,.F.); +#33789 = ADVANCED_FACE('',(#33790),#30183,.T.); +#33790 = FACE_BOUND('',#33791,.T.); +#33791 = EDGE_LOOP('',(#33792,#33815,#33816,#33817)); +#33792 = ORIENTED_EDGE('',*,*,#33793,.F.); +#33793 = EDGE_CURVE('',#30168,#33794,#33796,.T.); +#33794 = VERTEX_POINT('',#33795); +#33795 = CARTESIAN_POINT('',(31.300000000164,61.600008269707,40.)); +#33796 = SURFACE_CURVE('',#33797,(#33801,#33808),.PCURVE_S1.); +#33797 = LINE('',#33798,#33799); +#33798 = CARTESIAN_POINT('',(31.300000000164,58.600008269699,40.)); +#33799 = VECTOR('',#33800,1.); +#33800 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#33801 = PCURVE('',#30183,#33802); +#33802 = DEFINITIONAL_REPRESENTATION('',(#33803),#33807); +#33803 = LINE('',#33804,#33805); +#33804 = CARTESIAN_POINT('',(3.000000000007,1.5)); +#33805 = VECTOR('',#33806,1.); +#33806 = DIRECTION('',(-1.,0.)); +#33807 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33808 = PCURVE('',#30298,#33809); +#33809 = DEFINITIONAL_REPRESENTATION('',(#33810),#33814); +#33810 = LINE('',#33811,#33812); +#33811 = CARTESIAN_POINT('',(-33.30000000016,-58.59999999974)); +#33812 = VECTOR('',#33813,1.); +#33813 = DIRECTION('',(-4.866513180261E-57,-1.)); +#33814 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33815 = ORIENTED_EDGE('',*,*,#30167,.T.); +#33816 = ORIENTED_EDGE('',*,*,#30537,.F.); +#33817 = ORIENTED_EDGE('',*,*,#33818,.F.); +#33818 = EDGE_CURVE('',#33794,#30505,#33819,.T.); +#33819 = SURFACE_CURVE('',#33820,(#33824,#33831),.PCURVE_S1.); +#33820 = LINE('',#33821,#33822); +#33821 = CARTESIAN_POINT('',(31.300000000164,61.600008269707,38.5)); +#33822 = VECTOR('',#33823,1.); +#33823 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33824 = PCURVE('',#30183,#33825); +#33825 = DEFINITIONAL_REPRESENTATION('',(#33826),#33830); +#33826 = LINE('',#33827,#33828); +#33827 = CARTESIAN_POINT('',(0.,0.)); +#33828 = VECTOR('',#33829,1.); +#33829 = DIRECTION('',(2.043328855439E-16,1.)); +#33830 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33831 = PCURVE('',#30525,#33832); +#33832 = DEFINITIONAL_REPRESENTATION('',(#33833),#33837); +#33833 = LINE('',#33834,#33835); +#33834 = CARTESIAN_POINT('',(0.,0.)); +#33835 = VECTOR('',#33836,1.); +#33836 = DIRECTION('',(0.,1.)); +#33837 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33838 = ADVANCED_FACE('',(#33839),#30525,.F.); +#33839 = FACE_BOUND('',#33840,.F.); +#33840 = EDGE_LOOP('',(#33841,#33864,#33865,#33866)); +#33841 = ORIENTED_EDGE('',*,*,#33842,.T.); +#33842 = EDGE_CURVE('',#33843,#30477,#33845,.T.); +#33843 = VERTEX_POINT('',#33844); +#33844 = CARTESIAN_POINT('',(26.000012818078,66.900008269948,40.)); +#33845 = SURFACE_CURVE('',#33846,(#33850,#33857),.PCURVE_S1.); +#33846 = LINE('',#33847,#33848); +#33847 = CARTESIAN_POINT('',(26.000012818078,66.900008269948,38.5)); +#33848 = VECTOR('',#33849,1.); +#33849 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33850 = PCURVE('',#30525,#33851); +#33851 = DEFINITIONAL_REPRESENTATION('',(#33852),#33856); +#33852 = LINE('',#33853,#33854); +#33853 = CARTESIAN_POINT('',(1.570793908318,1.42108547152E-14)); +#33854 = VECTOR('',#33855,1.); +#33855 = DIRECTION('',(0.,1.)); +#33856 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33857 = PCURVE('',#30492,#33858); +#33858 = DEFINITIONAL_REPRESENTATION('',(#33859),#33863); +#33859 = LINE('',#33860,#33861); +#33860 = CARTESIAN_POINT('',(3.000012817892,4.544385905886E-27)); +#33861 = VECTOR('',#33862,1.); +#33862 = DIRECTION('',(-1.430644026125E-27,1.)); +#33863 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33864 = ORIENTED_EDGE('',*,*,#30504,.T.); +#33865 = ORIENTED_EDGE('',*,*,#33818,.F.); +#33866 = ORIENTED_EDGE('',*,*,#33867,.T.); +#33867 = EDGE_CURVE('',#33794,#33843,#33868,.T.); +#33868 = SURFACE_CURVE('',#33869,(#33874,#33881),.PCURVE_S1.); +#33869 = CIRCLE('',#33870,5.300000000012); +#33870 = AXIS2_PLACEMENT_3D('',#33871,#33872,#33873); +#33871 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,40.)); +#33872 = DIRECTION('',(1.420964917647E-27,1.980689724944E-15,1.)); +#33873 = DIRECTION('',(1.,1.019072868876E-113,-1.420964917647E-27)); +#33874 = PCURVE('',#30525,#33875); +#33875 = DEFINITIONAL_REPRESENTATION('',(#33876),#33880); +#33876 = LINE('',#33877,#33878); +#33877 = CARTESIAN_POINT('',(0.,1.5)); +#33878 = VECTOR('',#33879,1.); +#33879 = DIRECTION('',(1.,4.52346251152E-15)); +#33880 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33881 = PCURVE('',#30298,#33882); +#33882 = DEFINITIONAL_REPRESENTATION('',(#33883),#33887); +#33883 = CIRCLE('',#33884,5.300000000012); +#33884 = AXIS2_PLACEMENT_2D('',#33885,#33886); +#33885 = CARTESIAN_POINT('',(-28.00000000015,-61.59999999975)); +#33886 = DIRECTION('',(-1.,-8.723744686338E-59)); +#33887 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33888 = ADVANCED_FACE('',(#33889),#30492,.T.); +#33889 = FACE_BOUND('',#33890,.T.); +#33890 = EDGE_LOOP('',(#33891,#33912,#33913,#33914)); +#33891 = ORIENTED_EDGE('',*,*,#33892,.F.); +#33892 = EDGE_CURVE('',#33843,#32743,#33893,.T.); +#33893 = SURFACE_CURVE('',#33894,(#33898,#33905),.PCURVE_S1.); +#33894 = LINE('',#33895,#33896); +#33895 = CARTESIAN_POINT('',(26.000012818078,66.900008269948,40.)); +#33896 = VECTOR('',#33897,1.); +#33897 = DIRECTION('',(-1.,-4.736931332577E-14,1.514788829829E-27)); +#33898 = PCURVE('',#30492,#33899); +#33899 = DEFINITIONAL_REPRESENTATION('',(#33900),#33904); +#33900 = LINE('',#33901,#33902); +#33901 = CARTESIAN_POINT('',(3.000012817892,1.5)); +#33902 = VECTOR('',#33903,1.); +#33903 = DIRECTION('',(-1.,0.)); +#33904 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33905 = PCURVE('',#30298,#33906); +#33906 = DEFINITIONAL_REPRESENTATION('',(#33907),#33911); +#33907 = LINE('',#33908,#33909); +#33908 = CARTESIAN_POINT('',(-28.00001281807,-66.89999999999)); +#33909 = VECTOR('',#33910,1.); +#33910 = DIRECTION('',(1.,4.736931332577E-14)); +#33911 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33912 = ORIENTED_EDGE('',*,*,#33842,.T.); +#33913 = ORIENTED_EDGE('',*,*,#30476,.F.); +#33914 = ORIENTED_EDGE('',*,*,#32765,.F.); +#33915 = ADVANCED_FACE('',(#33916),#30403,.T.); +#33916 = FACE_BOUND('',#33917,.T.); +#33917 = EDGE_LOOP('',(#33918,#33919,#33920,#33921)); +#33918 = ORIENTED_EDGE('',*,*,#31774,.T.); +#33919 = ORIENTED_EDGE('',*,*,#32791,.T.); +#33920 = ORIENTED_EDGE('',*,*,#30386,.F.); +#33921 = ORIENTED_EDGE('',*,*,#33922,.F.); +#33922 = EDGE_CURVE('',#31775,#30364,#33923,.T.); +#33923 = SURFACE_CURVE('',#33924,(#33928,#33935),.PCURVE_S1.); +#33924 = LINE('',#33925,#33926); +#33925 = CARTESIAN_POINT('',(32.800000000164,61.600008269707,38.5)); +#33926 = VECTOR('',#33927,1.); +#33927 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33928 = PCURVE('',#30403,#33929); +#33929 = DEFINITIONAL_REPRESENTATION('',(#33930),#33934); +#33930 = LINE('',#33931,#33932); +#33931 = CARTESIAN_POINT('',(0.,0.)); +#33932 = VECTOR('',#33933,1.); +#33933 = DIRECTION('',(0.,1.)); +#33934 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33935 = PCURVE('',#30266,#33936); +#33936 = DEFINITIONAL_REPRESENTATION('',(#33937),#33941); +#33937 = LINE('',#33938,#33939); +#33938 = CARTESIAN_POINT('',(3.000000000007,5.942069174847E-15)); +#33939 = VECTOR('',#33940,1.); +#33940 = DIRECTION('',(-2.043328855439E-16,1.)); +#33941 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33942 = ADVANCED_FACE('',(#33943),#30266,.T.); +#33943 = FACE_BOUND('',#33944,.T.); +#33944 = EDGE_LOOP('',(#33945,#33946,#33947,#33948)); +#33945 = ORIENTED_EDGE('',*,*,#30252,.F.); +#33946 = ORIENTED_EDGE('',*,*,#31798,.T.); +#33947 = ORIENTED_EDGE('',*,*,#33922,.T.); +#33948 = ORIENTED_EDGE('',*,*,#30363,.F.); +#33949 = ADVANCED_FACE('',(#33950),#32353,.T.); +#33950 = FACE_BOUND('',#33951,.T.); +#33951 = EDGE_LOOP('',(#33952,#33975,#33976,#33977)); +#33952 = ORIENTED_EDGE('',*,*,#33953,.F.); +#33953 = EDGE_CURVE('',#32338,#33954,#33956,.T.); +#33954 = VERTEX_POINT('',#33955); +#33955 = CARTESIAN_POINT('',(26.000062083639,-66.89999173014,40.)); +#33956 = SURFACE_CURVE('',#33957,(#33961,#33968),.PCURVE_S1.); +#33957 = LINE('',#33958,#33959); +#33958 = CARTESIAN_POINT('',(23.000000000089,-66.89999173014,40.)); +#33959 = VECTOR('',#33960,1.); +#33960 = DIRECTION('',(1.,-2.418755841333E-12,3.369839924431E-27)); +#33961 = PCURVE('',#32353,#33962); +#33962 = DEFINITIONAL_REPRESENTATION('',(#33963),#33967); +#33963 = LINE('',#33964,#33965); +#33964 = CARTESIAN_POINT('',(3.00006208355,1.5)); +#33965 = VECTOR('',#33966,1.); +#33966 = DIRECTION('',(-1.,0.)); +#33967 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33968 = PCURVE('',#30298,#33969); +#33969 = DEFINITIONAL_REPRESENTATION('',(#33970),#33974); +#33970 = LINE('',#33971,#33972); +#33971 = CARTESIAN_POINT('',(-25.00000000008,66.900000000094)); +#33972 = VECTOR('',#33973,1.); +#33973 = DIRECTION('',(-1.,2.418755841333E-12)); +#33974 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33975 = ORIENTED_EDGE('',*,*,#32337,.T.); +#33976 = ORIENTED_EDGE('',*,*,#32571,.F.); +#33977 = ORIENTED_EDGE('',*,*,#33978,.F.); +#33978 = EDGE_CURVE('',#33954,#32539,#33979,.T.); +#33979 = SURFACE_CURVE('',#33980,(#33984,#33991),.PCURVE_S1.); +#33980 = LINE('',#33981,#33982); +#33981 = CARTESIAN_POINT('',(26.000062083639,-66.89999173014,38.5)); +#33982 = VECTOR('',#33983,1.); +#33983 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#33984 = PCURVE('',#32353,#33985); +#33985 = DEFINITIONAL_REPRESENTATION('',(#33986),#33990); +#33986 = LINE('',#33987,#33988); +#33987 = CARTESIAN_POINT('',(0.,0.)); +#33988 = VECTOR('',#33989,1.); +#33989 = DIRECTION('',(9.267335571612E-28,1.)); +#33990 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33991 = PCURVE('',#32559,#33992); +#33992 = DEFINITIONAL_REPRESENTATION('',(#33993),#33997); +#33993 = LINE('',#33994,#33995); +#33994 = CARTESIAN_POINT('',(0.,-1.42108547152E-14)); +#33995 = VECTOR('',#33996,1.); +#33996 = DIRECTION('',(0.,1.)); +#33997 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#33998 = ADVANCED_FACE('',(#33999),#32559,.F.); +#33999 = FACE_BOUND('',#34000,.F.); +#34000 = EDGE_LOOP('',(#34001,#34024,#34025,#34026)); +#34001 = ORIENTED_EDGE('',*,*,#34002,.T.); +#34002 = EDGE_CURVE('',#34003,#32511,#34005,.T.); +#34003 = VERTEX_POINT('',#34004); +#34004 = CARTESIAN_POINT('',(31.300000000168,-61.59999173041,40.)); +#34005 = SURFACE_CURVE('',#34006,(#34010,#34017),.PCURVE_S1.); +#34006 = LINE('',#34007,#34008); +#34007 = CARTESIAN_POINT('',(31.300000000168,-61.59999173041,38.5)); +#34008 = VECTOR('',#34009,1.); +#34009 = DIRECTION('',(4.484155085839E-44,1.7763568394E-15,1.)); +#34010 = PCURVE('',#32559,#34011); +#34011 = DEFINITIONAL_REPRESENTATION('',(#34012),#34016); +#34012 = LINE('',#34013,#34014); +#34013 = CARTESIAN_POINT('',(1.570784612912,0.)); +#34014 = VECTOR('',#34015,1.); +#34015 = DIRECTION('',(0.,1.)); +#34016 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34017 = PCURVE('',#32526,#34018); +#34018 = DEFINITIONAL_REPRESENTATION('',(#34019),#34023); +#34019 = LINE('',#34020,#34021); +#34020 = CARTESIAN_POINT('',(3.000000000046,-5.942069174924E-15)); +#34021 = VECTOR('',#34022,1.); +#34022 = DIRECTION('',(2.043328855439E-16,1.)); +#34023 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34024 = ORIENTED_EDGE('',*,*,#32538,.T.); +#34025 = ORIENTED_EDGE('',*,*,#33978,.F.); +#34026 = ORIENTED_EDGE('',*,*,#34027,.T.); +#34027 = EDGE_CURVE('',#33954,#34003,#34028,.T.); +#34028 = SURFACE_CURVE('',#34029,(#34034,#34041),.PCURVE_S1.); +#34029 = CIRCLE('',#34030,5.300000000105); +#34030 = AXIS2_PLACEMENT_3D('',#34031,#34032,#34033); +#34031 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,40.)); +#34032 = DIRECTION('',(1.42096491516E-27,1.980689724944E-15,1.)); +#34033 = DIRECTION('',(1.171388226813E-05,-0.999999999931, + 1.980689724808E-15)); +#34034 = PCURVE('',#32559,#34035); +#34035 = DEFINITIONAL_REPRESENTATION('',(#34036),#34040); +#34036 = LINE('',#34037,#34038); +#34037 = CARTESIAN_POINT('',(0.,1.5)); +#34038 = VECTOR('',#34039,1.); +#34039 = DIRECTION('',(1.,4.52348927994E-15)); +#34040 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34041 = PCURVE('',#30298,#34042); +#34042 = DEFINITIONAL_REPRESENTATION('',(#34043),#34047); +#34043 = CIRCLE('',#34044,5.300000000105); +#34044 = AXIS2_PLACEMENT_2D('',#34045,#34046); +#34045 = CARTESIAN_POINT('',(-28.00000000006,61.60000000036)); +#34046 = DIRECTION('',(-1.171388226813E-05,0.999999999931)); +#34047 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34048 = ADVANCED_FACE('',(#34049),#32526,.T.); +#34049 = FACE_BOUND('',#34050,.T.); +#34050 = EDGE_LOOP('',(#34051,#34072,#34073,#34074)); +#34051 = ORIENTED_EDGE('',*,*,#34052,.F.); +#34052 = EDGE_CURVE('',#34003,#32646,#34053,.T.); +#34053 = SURFACE_CURVE('',#34054,(#34058,#34065),.PCURVE_S1.); +#34054 = LINE('',#34055,#34056); +#34055 = CARTESIAN_POINT('',(31.300000000168,-61.59999173041,40.)); +#34056 = VECTOR('',#34057,1.); +#34057 = DIRECTION('',(-2.279657943862E-13,1.,-1.980689724944E-15)); +#34058 = PCURVE('',#32526,#34059); +#34059 = DEFINITIONAL_REPRESENTATION('',(#34060),#34064); +#34060 = LINE('',#34061,#34062); +#34061 = CARTESIAN_POINT('',(3.000000000046,1.5)); +#34062 = VECTOR('',#34063,1.); +#34063 = DIRECTION('',(-1.,0.)); +#34064 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34065 = PCURVE('',#30298,#34066); +#34066 = DEFINITIONAL_REPRESENTATION('',(#34067),#34071); +#34067 = LINE('',#34068,#34069); +#34068 = CARTESIAN_POINT('',(-33.30000000016,61.600000000364)); +#34069 = VECTOR('',#34070,1.); +#34070 = DIRECTION('',(2.279657943862E-13,-1.)); +#34071 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34072 = ORIENTED_EDGE('',*,*,#34002,.T.); +#34073 = ORIENTED_EDGE('',*,*,#32510,.F.); +#34074 = ORIENTED_EDGE('',*,*,#32668,.F.); +#34075 = ADVANCED_FACE('',(#34076),#31085,.T.); +#34076 = FACE_BOUND('',#34077,.T.); +#34077 = EDGE_LOOP('',(#34078,#34079,#34080,#34081)); +#34078 = ORIENTED_EDGE('',*,*,#31068,.T.); +#34079 = ORIENTED_EDGE('',*,*,#32694,.T.); +#34080 = ORIENTED_EDGE('',*,*,#32435,.F.); +#34081 = ORIENTED_EDGE('',*,*,#32597,.F.); +#34082 = ADVANCED_FACE('',(#34083),#31867,.T.); +#34083 = FACE_BOUND('',#34084,.T.); +#34084 = EDGE_LOOP('',(#34085,#34086,#34109,#34132)); +#34085 = ORIENTED_EDGE('',*,*,#31851,.T.); +#34086 = ORIENTED_EDGE('',*,*,#34087,.T.); +#34087 = EDGE_CURVE('',#31822,#34088,#34090,.T.); +#34088 = VERTEX_POINT('',#34089); +#34089 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,40.)); +#34090 = SURFACE_CURVE('',#34091,(#34095,#34102),.PCURVE_S1.); +#34091 = LINE('',#34092,#34093); +#34092 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,38.5)); +#34093 = VECTOR('',#34094,1.); +#34094 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34095 = PCURVE('',#31867,#34096); +#34096 = DEFINITIONAL_REPRESENTATION('',(#34097),#34101); +#34097 = LINE('',#34098,#34099); +#34098 = CARTESIAN_POINT('',(40.600000000031,5.329316098197E-26)); +#34099 = VECTOR('',#34100,1.); +#34100 = DIRECTION('',(-1.312639433053E-27,1.)); +#34101 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34102 = PCURVE('',#31839,#34103); +#34103 = DEFINITIONAL_REPRESENTATION('',(#34104),#34108); +#34104 = LINE('',#34105,#34106); +#34105 = CARTESIAN_POINT('',(0.,0.)); +#34106 = VECTOR('',#34107,1.); +#34107 = DIRECTION('',(1.980689724944E-15,1.)); +#34108 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34109 = ORIENTED_EDGE('',*,*,#34110,.F.); +#34110 = EDGE_CURVE('',#34111,#34088,#34113,.T.); +#34111 = VERTEX_POINT('',#34112); +#34112 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,40.)); +#34113 = SURFACE_CURVE('',#34114,(#34118,#34125),.PCURVE_S1.); +#34114 = LINE('',#34115,#34116); +#34115 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,40.)); +#34116 = VECTOR('',#34117,1.); +#34117 = DIRECTION('',(1.,-5.469078939036E-14,-1.312639433053E-27)); +#34118 = PCURVE('',#31867,#34119); +#34119 = DEFINITIONAL_REPRESENTATION('',(#34120),#34124); +#34120 = LINE('',#34121,#34122); +#34121 = CARTESIAN_POINT('',(-1.968959149579E-27,1.5)); +#34122 = VECTOR('',#34123,1.); +#34123 = DIRECTION('',(1.,0.)); +#34124 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34125 = PCURVE('',#30298,#34126); +#34126 = DEFINITIONAL_REPRESENTATION('',(#34127),#34131); +#34127 = LINE('',#34128,#34129); +#34128 = CARTESIAN_POINT('',(15.299999999872,-62.09999999973)); +#34129 = VECTOR('',#34130,1.); +#34130 = DIRECTION('',(-1.,5.469078939036E-14)); +#34131 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34132 = ORIENTED_EDGE('',*,*,#34133,.F.); +#34133 = EDGE_CURVE('',#31852,#34111,#34134,.T.); +#34134 = SURFACE_CURVE('',#34135,(#34139,#34146),.PCURVE_S1.); +#34135 = LINE('',#34136,#34137); +#34136 = CARTESIAN_POINT('',(-17.29999999987,62.100008269692,38.5)); +#34137 = VECTOR('',#34138,1.); +#34138 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34139 = PCURVE('',#31867,#34140); +#34140 = DEFINITIONAL_REPRESENTATION('',(#34141),#34145); +#34141 = LINE('',#34142,#34143); +#34142 = CARTESIAN_POINT('',(0.,0.)); +#34143 = VECTOR('',#34144,1.); +#34144 = DIRECTION('',(-1.312639433053E-27,1.)); +#34145 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34146 = PCURVE('',#31895,#34147); +#34147 = DEFINITIONAL_REPRESENTATION('',(#34148),#34152); +#34148 = LINE('',#34149,#34150); +#34149 = CARTESIAN_POINT('',(28.499999999975,-5.013175320316E-14)); +#34150 = VECTOR('',#34151,1.); +#34151 = DIRECTION('',(-1.980689724944E-15,1.)); +#34152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34153 = ADVANCED_FACE('',(#34154),#31895,.T.); +#34154 = FACE_BOUND('',#34155,.T.); +#34155 = EDGE_LOOP('',(#34156,#34157,#34158,#34181)); +#34156 = ORIENTED_EDGE('',*,*,#31879,.T.); +#34157 = ORIENTED_EDGE('',*,*,#34133,.T.); +#34158 = ORIENTED_EDGE('',*,*,#34159,.F.); +#34159 = EDGE_CURVE('',#34160,#34111,#34162,.T.); +#34160 = VERTEX_POINT('',#34161); +#34161 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,40.)); +#34162 = SURFACE_CURVE('',#34163,(#34167,#34174),.PCURVE_S1.); +#34163 = LINE('',#34164,#34165); +#34164 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,40.)); +#34165 = VECTOR('',#34166,1.); +#34166 = DIRECTION('',(-2.81449061189E-42,1.,-1.980689724944E-15)); +#34167 = PCURVE('',#31895,#34168); +#34168 = DEFINITIONAL_REPRESENTATION('',(#34169),#34173); +#34169 = LINE('',#34170,#34171); +#34170 = CARTESIAN_POINT('',(-2.971034587416E-15,1.5)); +#34171 = VECTOR('',#34172,1.); +#34172 = DIRECTION('',(1.,0.)); +#34173 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34174 = PCURVE('',#30298,#34175); +#34175 = DEFINITIONAL_REPRESENTATION('',(#34176),#34180); +#34176 = LINE('',#34177,#34178); +#34177 = CARTESIAN_POINT('',(15.299999999872,-33.59999999976)); +#34178 = VECTOR('',#34179,1.); +#34179 = DIRECTION('',(-4.866513180261E-57,-1.)); +#34180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34181 = ORIENTED_EDGE('',*,*,#34182,.F.); +#34182 = EDGE_CURVE('',#31880,#34160,#34183,.T.); +#34183 = SURFACE_CURVE('',#34184,(#34188,#34195),.PCURVE_S1.); +#34184 = LINE('',#34185,#34186); +#34185 = CARTESIAN_POINT('',(-17.29999999987,33.600008269717,38.5)); +#34186 = VECTOR('',#34187,1.); +#34187 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34188 = PCURVE('',#31895,#34189); +#34189 = DEFINITIONAL_REPRESENTATION('',(#34190),#34194); +#34190 = LINE('',#34191,#34192); +#34191 = CARTESIAN_POINT('',(0.,0.)); +#34192 = VECTOR('',#34193,1.); +#34193 = DIRECTION('',(-1.980689724944E-15,1.)); +#34194 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34195 = PCURVE('',#31921,#34196); +#34196 = DEFINITIONAL_REPRESENTATION('',(#34197),#34201); +#34197 = LINE('',#34198,#34199); +#34198 = CARTESIAN_POINT('',(40.600000000031,-5.324918083523E-26)); +#34199 = VECTOR('',#34200,1.); +#34200 = DIRECTION('',(1.311556178207E-27,1.)); +#34201 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34202 = ADVANCED_FACE('',(#34203),#31921,.T.); +#34203 = FACE_BOUND('',#34204,.T.); +#34204 = EDGE_LOOP('',(#34205,#34206,#34207,#34230)); +#34205 = ORIENTED_EDGE('',*,*,#31907,.T.); +#34206 = ORIENTED_EDGE('',*,*,#34182,.T.); +#34207 = ORIENTED_EDGE('',*,*,#34208,.F.); +#34208 = EDGE_CURVE('',#34209,#34160,#34211,.T.); +#34209 = VERTEX_POINT('',#34210); +#34210 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,40.)); +#34211 = SURFACE_CURVE('',#34212,(#34216,#34223),.PCURVE_S1.); +#34212 = LINE('',#34213,#34214); +#34213 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,40.)); +#34214 = VECTOR('',#34215,1.); +#34215 = DIRECTION('',(-1.,5.523769728426E-14,1.311556178207E-27)); +#34216 = PCURVE('',#31921,#34217); +#34217 = DEFINITIONAL_REPRESENTATION('',(#34218),#34222); +#34218 = LINE('',#34219,#34220); +#34219 = CARTESIAN_POINT('',(1.96733426731E-27,1.5)); +#34220 = VECTOR('',#34221,1.); +#34221 = DIRECTION('',(1.,1.793662034336E-43)); +#34222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34223 = PCURVE('',#30298,#34224); +#34224 = DEFINITIONAL_REPRESENTATION('',(#34225),#34229); +#34225 = LINE('',#34226,#34227); +#34226 = CARTESIAN_POINT('',(-25.30000000015,-33.59999999976)); +#34227 = VECTOR('',#34228,1.); +#34228 = DIRECTION('',(1.,-5.523769728426E-14)); +#34229 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34230 = ORIENTED_EDGE('',*,*,#34231,.F.); +#34231 = EDGE_CURVE('',#31824,#34209,#34232,.T.); +#34232 = SURFACE_CURVE('',#34233,(#34237,#34244),.PCURVE_S1.); +#34233 = LINE('',#34234,#34235); +#34234 = CARTESIAN_POINT('',(23.300000000161,33.600008269715,38.5)); +#34235 = VECTOR('',#34236,1.); +#34236 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34237 = PCURVE('',#31921,#34238); +#34238 = DEFINITIONAL_REPRESENTATION('',(#34239),#34243); +#34239 = LINE('',#34240,#34241); +#34240 = CARTESIAN_POINT('',(0.,0.)); +#34241 = VECTOR('',#34242,1.); +#34242 = DIRECTION('',(1.311556178207E-27,1.)); +#34243 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34244 = PCURVE('',#31839,#34245); +#34245 = DEFINITIONAL_REPRESENTATION('',(#34246),#34250); +#34246 = LINE('',#34247,#34248); +#34247 = CARTESIAN_POINT('',(28.499999999975,5.013175320316E-14)); +#34248 = VECTOR('',#34249,1.); +#34249 = DIRECTION('',(1.980689724944E-15,1.)); +#34250 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34251 = ADVANCED_FACE('',(#34252),#31839,.T.); +#34252 = FACE_BOUND('',#34253,.T.); +#34253 = EDGE_LOOP('',(#34254,#34255,#34256,#34277)); +#34254 = ORIENTED_EDGE('',*,*,#31821,.T.); +#34255 = ORIENTED_EDGE('',*,*,#34231,.T.); +#34256 = ORIENTED_EDGE('',*,*,#34257,.F.); +#34257 = EDGE_CURVE('',#34088,#34209,#34258,.T.); +#34258 = SURFACE_CURVE('',#34259,(#34263,#34270),.PCURVE_S1.); +#34259 = LINE('',#34260,#34261); +#34260 = CARTESIAN_POINT('',(23.300000000161,62.10000826969,40.)); +#34261 = VECTOR('',#34262,1.); +#34262 = DIRECTION('',(2.81449061189E-42,-1.,1.980689724944E-15)); +#34263 = PCURVE('',#31839,#34264); +#34264 = DEFINITIONAL_REPRESENTATION('',(#34265),#34269); +#34265 = LINE('',#34266,#34267); +#34266 = CARTESIAN_POINT('',(2.971034587416E-15,1.5)); +#34267 = VECTOR('',#34268,1.); +#34268 = DIRECTION('',(1.,0.)); +#34269 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34270 = PCURVE('',#30298,#34271); +#34271 = DEFINITIONAL_REPRESENTATION('',(#34272),#34276); +#34272 = LINE('',#34273,#34274); +#34273 = CARTESIAN_POINT('',(-25.30000000015,-62.09999999973)); +#34274 = VECTOR('',#34275,1.); +#34275 = DIRECTION('',(4.866513180261E-57,1.)); +#34276 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34277 = ORIENTED_EDGE('',*,*,#34087,.F.); +#34278 = ADVANCED_FACE('',(#34279),#31952,.F.); +#34279 = FACE_BOUND('',#34280,.F.); +#34280 = EDGE_LOOP('',(#34281,#34304,#34305,#34306)); +#34281 = ORIENTED_EDGE('',*,*,#34282,.T.); +#34282 = EDGE_CURVE('',#34283,#31936,#34285,.T.); +#34283 = VERTEX_POINT('',#34284); +#34284 = CARTESIAN_POINT('',(27.050000000063,-61.5999917304,40.)); +#34285 = SEAM_CURVE('',#34286,(#34290,#34297),.PCURVE_S1.); +#34286 = LINE('',#34287,#34288); +#34287 = CARTESIAN_POINT('',(27.050000000063,-61.5999917304,38.5)); +#34288 = VECTOR('',#34289,1.); +#34289 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#34290 = PCURVE('',#31952,#34291); +#34291 = DEFINITIONAL_REPRESENTATION('',(#34292),#34296); +#34292 = LINE('',#34293,#34294); +#34293 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#34294 = VECTOR('',#34295,1.); +#34295 = DIRECTION('',(0.,-1.)); +#34296 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34297 = PCURVE('',#31952,#34298); +#34298 = DEFINITIONAL_REPRESENTATION('',(#34299),#34303); +#34299 = LINE('',#34300,#34301); +#34300 = CARTESIAN_POINT('',(3.14159265359,0.)); +#34301 = VECTOR('',#34302,1.); +#34302 = DIRECTION('',(0.,-1.)); +#34303 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34304 = ORIENTED_EDGE('',*,*,#31935,.T.); +#34305 = ORIENTED_EDGE('',*,*,#34282,.F.); +#34306 = ORIENTED_EDGE('',*,*,#34307,.T.); +#34307 = EDGE_CURVE('',#34283,#34283,#34308,.T.); +#34308 = SURFACE_CURVE('',#34309,(#34314,#34321),.PCURVE_S1.); +#34309 = CIRCLE('',#34310,1.05); +#34310 = AXIS2_PLACEMENT_3D('',#34311,#34312,#34313); +#34311 = CARTESIAN_POINT('',(26.000000000063,-61.5999917304,40.)); +#34312 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#34313 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#34314 = PCURVE('',#31952,#34315); +#34315 = DEFINITIONAL_REPRESENTATION('',(#34316),#34320); +#34316 = LINE('',#34317,#34318); +#34317 = CARTESIAN_POINT('',(6.28318530718,1.5)); +#34318 = VECTOR('',#34319,1.); +#34319 = DIRECTION('',(-1.,0.)); +#34320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34321 = PCURVE('',#30298,#34322); +#34322 = DEFINITIONAL_REPRESENTATION('',(#34323),#34331); +#34323 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#34324,#34325,#34326,#34327 + ,#34328,#34329,#34330),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#34324 = CARTESIAN_POINT('',(-26.95000000006,61.60000000036)); +#34325 = CARTESIAN_POINT('',(-26.95000000006,59.781346652413)); +#34326 = CARTESIAN_POINT('',(-28.52500000006,60.690673326387)); +#34327 = CARTESIAN_POINT('',(-30.10000000006,61.60000000036)); +#34328 = CARTESIAN_POINT('',(-28.52500000006,62.509326674334)); +#34329 = CARTESIAN_POINT('',(-26.95000000006,63.418653348308)); +#34330 = CARTESIAN_POINT('',(-26.95000000006,61.60000000036)); +#34331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34332 = ADVANCED_FACE('',(#34333),#31983,.F.); +#34333 = FACE_BOUND('',#34334,.F.); +#34334 = EDGE_LOOP('',(#34335,#34358,#34359,#34360)); +#34335 = ORIENTED_EDGE('',*,*,#34336,.T.); +#34336 = EDGE_CURVE('',#34337,#31967,#34339,.T.); +#34337 = VERTEX_POINT('',#34338); +#34338 = CARTESIAN_POINT('',(-28.95000000003,-61.59999173032,40.)); +#34339 = SEAM_CURVE('',#34340,(#34344,#34351),.PCURVE_S1.); +#34340 = LINE('',#34341,#34342); +#34341 = CARTESIAN_POINT('',(-28.95000000003,-61.59999173032,38.5)); +#34342 = VECTOR('',#34343,1.); +#34343 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#34344 = PCURVE('',#31983,#34345); +#34345 = DEFINITIONAL_REPRESENTATION('',(#34346),#34350); +#34346 = LINE('',#34347,#34348); +#34347 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#34348 = VECTOR('',#34349,1.); +#34349 = DIRECTION('',(0.,-1.)); +#34350 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34351 = PCURVE('',#31983,#34352); +#34352 = DEFINITIONAL_REPRESENTATION('',(#34353),#34357); +#34353 = LINE('',#34354,#34355); +#34354 = CARTESIAN_POINT('',(3.14159265359,0.)); +#34355 = VECTOR('',#34356,1.); +#34356 = DIRECTION('',(0.,-1.)); +#34357 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34358 = ORIENTED_EDGE('',*,*,#31966,.T.); +#34359 = ORIENTED_EDGE('',*,*,#34336,.F.); +#34360 = ORIENTED_EDGE('',*,*,#34361,.T.); +#34361 = EDGE_CURVE('',#34337,#34337,#34362,.T.); +#34362 = SURFACE_CURVE('',#34363,(#34368,#34375),.PCURVE_S1.); +#34363 = CIRCLE('',#34364,1.05); +#34364 = AXIS2_PLACEMENT_3D('',#34365,#34366,#34367); +#34365 = CARTESIAN_POINT('',(-30.00000000003,-61.59999173032,40.)); +#34366 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#34367 = DIRECTION('',(-1.,-1.019072868876E-113,1.420964917647E-27)); +#34368 = PCURVE('',#31983,#34369); +#34369 = DEFINITIONAL_REPRESENTATION('',(#34370),#34374); +#34370 = LINE('',#34371,#34372); +#34371 = CARTESIAN_POINT('',(6.28318530718,1.5)); +#34372 = VECTOR('',#34373,1.); +#34373 = DIRECTION('',(-1.,0.)); +#34374 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34375 = PCURVE('',#30298,#34376); +#34376 = DEFINITIONAL_REPRESENTATION('',(#34377),#34385); +#34377 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#34378,#34379,#34380,#34381 + ,#34382,#34383,#34384),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#34378 = CARTESIAN_POINT('',(29.050000000031,61.60000000028)); +#34379 = CARTESIAN_POINT('',(29.050000000031,59.781346652332)); +#34380 = CARTESIAN_POINT('',(27.475000000031,60.690673326306)); +#34381 = CARTESIAN_POINT('',(25.900000000031,61.60000000028)); +#34382 = CARTESIAN_POINT('',(27.475000000031,62.509326674253)); +#34383 = CARTESIAN_POINT('',(29.050000000031,63.418653348227)); +#34384 = CARTESIAN_POINT('',(29.050000000031,61.60000000028)); +#34385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34386 = ADVANCED_FACE('',(#34387),#32014,.F.); +#34387 = FACE_BOUND('',#34388,.F.); +#34388 = EDGE_LOOP('',(#34389,#34412,#34413,#34414)); +#34389 = ORIENTED_EDGE('',*,*,#34390,.T.); +#34390 = EDGE_CURVE('',#34391,#31998,#34393,.T.); +#34391 = VERTEX_POINT('',#34392); +#34392 = CARTESIAN_POINT('',(27.050000000152,61.600008269707,40.)); +#34393 = SEAM_CURVE('',#34394,(#34398,#34405),.PCURVE_S1.); +#34394 = LINE('',#34395,#34396); +#34395 = CARTESIAN_POINT('',(27.050000000152,61.600008269707,38.5)); +#34396 = VECTOR('',#34397,1.); +#34397 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#34398 = PCURVE('',#32014,#34399); +#34399 = DEFINITIONAL_REPRESENTATION('',(#34400),#34404); +#34400 = LINE('',#34401,#34402); +#34401 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#34402 = VECTOR('',#34403,1.); +#34403 = DIRECTION('',(0.,-1.)); +#34404 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34405 = PCURVE('',#32014,#34406); +#34406 = DEFINITIONAL_REPRESENTATION('',(#34407),#34411); +#34407 = LINE('',#34408,#34409); +#34408 = CARTESIAN_POINT('',(3.14159265359,0.)); +#34409 = VECTOR('',#34410,1.); +#34410 = DIRECTION('',(0.,-1.)); +#34411 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34412 = ORIENTED_EDGE('',*,*,#31997,.T.); +#34413 = ORIENTED_EDGE('',*,*,#34390,.F.); +#34414 = ORIENTED_EDGE('',*,*,#34415,.T.); +#34415 = EDGE_CURVE('',#34391,#34391,#34416,.T.); +#34416 = SURFACE_CURVE('',#34417,(#34422,#34429),.PCURVE_S1.); +#34417 = CIRCLE('',#34418,1.05); +#34418 = AXIS2_PLACEMENT_3D('',#34419,#34420,#34421); +#34419 = CARTESIAN_POINT('',(26.000000000152,61.600008269707,40.)); +#34420 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#34421 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#34422 = PCURVE('',#32014,#34423); +#34423 = DEFINITIONAL_REPRESENTATION('',(#34424),#34428); +#34424 = LINE('',#34425,#34426); +#34425 = CARTESIAN_POINT('',(6.28318530718,1.5)); +#34426 = VECTOR('',#34427,1.); +#34427 = DIRECTION('',(-1.,0.)); +#34428 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34429 = PCURVE('',#30298,#34430); +#34430 = DEFINITIONAL_REPRESENTATION('',(#34431),#34439); +#34431 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#34432,#34433,#34434,#34435 + ,#34436,#34437,#34438),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#34432 = CARTESIAN_POINT('',(-26.95000000015,-61.59999999975)); +#34433 = CARTESIAN_POINT('',(-26.95000000015,-63.4186533477)); +#34434 = CARTESIAN_POINT('',(-28.52500000015,-62.50932667372)); +#34435 = CARTESIAN_POINT('',(-30.10000000015,-61.59999999975)); +#34436 = CARTESIAN_POINT('',(-28.52500000015,-60.69067332578)); +#34437 = CARTESIAN_POINT('',(-26.95000000015,-59.7813466518)); +#34438 = CARTESIAN_POINT('',(-26.95000000015,-61.59999999975)); +#34439 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34440 = ADVANCED_FACE('',(#34441),#32045,.F.); +#34441 = FACE_BOUND('',#34442,.F.); +#34442 = EDGE_LOOP('',(#34443,#34466,#34467,#34468)); +#34443 = ORIENTED_EDGE('',*,*,#34444,.T.); +#34444 = EDGE_CURVE('',#34445,#32029,#34447,.T.); +#34445 = VERTEX_POINT('',#34446); +#34446 = CARTESIAN_POINT('',(-28.94999999994,61.600008269706,40.)); +#34447 = SEAM_CURVE('',#34448,(#34452,#34459),.PCURVE_S1.); +#34448 = LINE('',#34449,#34450); +#34449 = CARTESIAN_POINT('',(-28.94999999994,61.600008269706,38.5)); +#34450 = VECTOR('',#34451,1.); +#34451 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#34452 = PCURVE('',#32045,#34453); +#34453 = DEFINITIONAL_REPRESENTATION('',(#34454),#34458); +#34454 = LINE('',#34455,#34456); +#34455 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#34456 = VECTOR('',#34457,1.); +#34457 = DIRECTION('',(0.,-1.)); +#34458 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34459 = PCURVE('',#32045,#34460); +#34460 = DEFINITIONAL_REPRESENTATION('',(#34461),#34465); +#34461 = LINE('',#34462,#34463); +#34462 = CARTESIAN_POINT('',(3.14159265359,0.)); +#34463 = VECTOR('',#34464,1.); +#34464 = DIRECTION('',(0.,-1.)); +#34465 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34466 = ORIENTED_EDGE('',*,*,#32028,.T.); +#34467 = ORIENTED_EDGE('',*,*,#34444,.F.); +#34468 = ORIENTED_EDGE('',*,*,#34469,.T.); +#34469 = EDGE_CURVE('',#34445,#34445,#34470,.T.); +#34470 = SURFACE_CURVE('',#34471,(#34476,#34483),.PCURVE_S1.); +#34471 = CIRCLE('',#34472,1.05); +#34472 = AXIS2_PLACEMENT_3D('',#34473,#34474,#34475); +#34473 = CARTESIAN_POINT('',(-29.99999999994,61.600008269706,40.)); +#34474 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#34475 = DIRECTION('',(-1.,-6.37236764453E-58,1.420964917647E-27)); +#34476 = PCURVE('',#32045,#34477); +#34477 = DEFINITIONAL_REPRESENTATION('',(#34478),#34482); +#34478 = LINE('',#34479,#34480); +#34479 = CARTESIAN_POINT('',(6.28318530718,1.5)); +#34480 = VECTOR('',#34481,1.); +#34481 = DIRECTION('',(-1.,0.)); +#34482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34483 = PCURVE('',#30298,#34484); +#34484 = DEFINITIONAL_REPRESENTATION('',(#34485),#34493); +#34485 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#34486,#34487,#34488,#34489 + ,#34490,#34491,#34492),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#34486 = CARTESIAN_POINT('',(29.049999999943,-61.59999999975)); +#34487 = CARTESIAN_POINT('',(29.049999999943,-63.4186533477)); +#34488 = CARTESIAN_POINT('',(27.474999999943,-62.50932667372)); +#34489 = CARTESIAN_POINT('',(25.899999999943,-61.59999999975)); +#34490 = CARTESIAN_POINT('',(27.474999999943,-60.69067332577)); +#34491 = CARTESIAN_POINT('',(29.049999999943,-59.7813466518)); +#34492 = CARTESIAN_POINT('',(29.049999999943,-61.59999999975)); +#34493 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34494 = ADVANCED_FACE('',(#34495),#32076,.F.); +#34495 = FACE_BOUND('',#34496,.F.); +#34496 = EDGE_LOOP('',(#34497,#34520,#34521,#34522)); +#34497 = ORIENTED_EDGE('',*,*,#34498,.T.); +#34498 = EDGE_CURVE('',#34499,#32060,#34501,.T.); +#34499 = VERTEX_POINT('',#34500); +#34500 = CARTESIAN_POINT('',(-16.15444504208,-33.23835181012,40.)); +#34501 = SEAM_CURVE('',#34502,(#34506,#34513),.PCURVE_S1.); +#34502 = LINE('',#34503,#34504); +#34503 = CARTESIAN_POINT('',(-16.15444504208,-33.23835181012,38.5)); +#34504 = VECTOR('',#34505,1.); +#34505 = DIRECTION('',(-4.484155085839E-44,7.171696191935E-87,-1.)); +#34506 = PCURVE('',#32076,#34507); +#34507 = DEFINITIONAL_REPRESENTATION('',(#34508),#34512); +#34508 = LINE('',#34509,#34510); +#34509 = CARTESIAN_POINT('',(-3.14159265359,0.)); +#34510 = VECTOR('',#34511,1.); +#34511 = DIRECTION('',(0.,-1.)); +#34512 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34513 = PCURVE('',#32076,#34514); +#34514 = DEFINITIONAL_REPRESENTATION('',(#34515),#34519); +#34515 = LINE('',#34516,#34517); +#34516 = CARTESIAN_POINT('',(3.14159265359,0.)); +#34517 = VECTOR('',#34518,1.); +#34518 = DIRECTION('',(0.,-1.)); +#34519 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34520 = ORIENTED_EDGE('',*,*,#32059,.T.); +#34521 = ORIENTED_EDGE('',*,*,#34498,.F.); +#34522 = ORIENTED_EDGE('',*,*,#34523,.T.); +#34523 = EDGE_CURVE('',#34499,#34499,#34524,.T.); +#34524 = SURFACE_CURVE('',#34525,(#34530,#34537),.PCURVE_S1.); +#34525 = CIRCLE('',#34526,1.05); +#34526 = AXIS2_PLACEMENT_3D('',#34527,#34528,#34529); +#34527 = CARTESIAN_POINT('',(-17.20444504208,-33.23835181012,40.)); +#34528 = DIRECTION('',(-1.420964917647E-27,-1.980689724944E-15,-1.)); +#34529 = DIRECTION('',(-1.,3.186183822265E-58,1.420964917647E-27)); +#34530 = PCURVE('',#32076,#34531); +#34531 = DEFINITIONAL_REPRESENTATION('',(#34532),#34536); +#34532 = LINE('',#34533,#34534); +#34533 = CARTESIAN_POINT('',(6.28318530718,1.5)); +#34534 = VECTOR('',#34535,1.); +#34535 = DIRECTION('',(-1.,0.)); +#34536 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34537 = PCURVE('',#30298,#34538); +#34538 = DEFINITIONAL_REPRESENTATION('',(#34539),#34547); +#34539 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#34540,#34541,#34542,#34543 + ,#34544,#34545,#34546),.UNSPECIFIED.,.T.,.F.) +B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),(-2.094395102393,0., + 2.094395102393,4.188790204786,6.28318530718,8.377580409573), +.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#34540 = CARTESIAN_POINT('',(16.254445042088,33.238360080074)); +#34541 = CARTESIAN_POINT('',(16.254445042088,31.419706732126)); +#34542 = CARTESIAN_POINT('',(14.679445042088,32.3290334061)); +#34543 = CARTESIAN_POINT('',(13.104445042088,33.238360080074)); +#34544 = CARTESIAN_POINT('',(14.679445042088,34.147686754047)); +#34545 = CARTESIAN_POINT('',(16.254445042088,35.057013428021)); +#34546 = CARTESIAN_POINT('',(16.254445042088,33.238360080074)); +#34547 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34548 = ADVANCED_FACE('',(#34549),#31687,.T.); +#34549 = FACE_BOUND('',#34550,.T.); +#34550 = EDGE_LOOP('',(#34551,#34552,#34553,#34576)); +#34551 = ORIENTED_EDGE('',*,*,#31671,.T.); +#34552 = ORIENTED_EDGE('',*,*,#32949,.T.); +#34553 = ORIENTED_EDGE('',*,*,#34554,.F.); +#34554 = EDGE_CURVE('',#34555,#32927,#34557,.T.); +#34555 = VERTEX_POINT('',#34556); +#34556 = CARTESIAN_POINT('',(23.000000000186,66.600008269742,40.)); +#34557 = SURFACE_CURVE('',#34558,(#34562,#34569),.PCURVE_S1.); +#34558 = LINE('',#34559,#34560); +#34559 = CARTESIAN_POINT('',(26.000000000131,66.60000826975,40.)); +#34560 = VECTOR('',#34561,1.); +#34561 = DIRECTION('',(-1.,-2.870402328519E-12,7.106354245054E-27)); +#34562 = PCURVE('',#31687,#34563); +#34563 = DEFINITIONAL_REPRESENTATION('',(#34564),#34568); +#34564 = LINE('',#34565,#34566); +#34565 = CARTESIAN_POINT('',(-2.999999999945,1.5)); +#34566 = VECTOR('',#34567,1.); +#34567 = DIRECTION('',(1.,0.)); +#34568 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34569 = PCURVE('',#30298,#34570); +#34570 = DEFINITIONAL_REPRESENTATION('',(#34571),#34575); +#34571 = LINE('',#34572,#34573); +#34572 = CARTESIAN_POINT('',(-28.00000000013,-66.59999999979)); +#34573 = VECTOR('',#34574,1.); +#34574 = DIRECTION('',(1.,2.870402328519E-12)); +#34575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34576 = ORIENTED_EDGE('',*,*,#34577,.F.); +#34577 = EDGE_CURVE('',#31672,#34555,#34578,.T.); +#34578 = SURFACE_CURVE('',#34579,(#34583,#34590),.PCURVE_S1.); +#34579 = LINE('',#34580,#34581); +#34580 = CARTESIAN_POINT('',(23.000000000186,66.600008269742,38.5)); +#34581 = VECTOR('',#34582,1.); +#34582 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34583 = PCURVE('',#31687,#34584); +#34584 = DEFINITIONAL_REPRESENTATION('',(#34585),#34589); +#34585 = LINE('',#34586,#34587); +#34586 = CARTESIAN_POINT('',(0.,0.)); +#34587 = VECTOR('',#34588,1.); +#34588 = DIRECTION('',(7.106354245054E-27,1.)); +#34589 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34590 = PCURVE('',#31715,#34591); +#34591 = DEFINITIONAL_REPRESENTATION('',(#34592),#34596); +#34592 = LINE('',#34593,#34594); +#34593 = CARTESIAN_POINT('',(0.300000000207,-5.942069178927E-16)); +#34594 = VECTOR('',#34595,1.); +#34595 = DIRECTION('',(1.980689724944E-15,1.)); +#34596 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34597 = ADVANCED_FACE('',(#34598),#31715,.T.); +#34598 = FACE_BOUND('',#34599,.T.); +#34599 = EDGE_LOOP('',(#34600,#34601,#34602,#34603)); +#34600 = ORIENTED_EDGE('',*,*,#32742,.F.); +#34601 = ORIENTED_EDGE('',*,*,#31699,.T.); +#34602 = ORIENTED_EDGE('',*,*,#34577,.T.); +#34603 = ORIENTED_EDGE('',*,*,#34604,.F.); +#34604 = EDGE_CURVE('',#32743,#34555,#34605,.T.); +#34605 = SURFACE_CURVE('',#34606,(#34610,#34617),.PCURVE_S1.); +#34606 = LINE('',#34607,#34608); +#34607 = CARTESIAN_POINT('',(23.000000000186,66.60000826979,40.)); +#34608 = VECTOR('',#34609,1.); +#34609 = DIRECTION('',(2.960594730768E-14,-1.,1.980689724944E-15)); +#34610 = PCURVE('',#31715,#34611); +#34611 = DEFINITIONAL_REPRESENTATION('',(#34612),#34616); +#34612 = LINE('',#34613,#34614); +#34613 = CARTESIAN_POINT('',(0.300000000159,1.5)); +#34614 = VECTOR('',#34615,1.); +#34615 = DIRECTION('',(1.,0.)); +#34616 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34617 = PCURVE('',#30298,#34618); +#34618 = DEFINITIONAL_REPRESENTATION('',(#34619),#34623); +#34619 = LINE('',#34620,#34621); +#34620 = CARTESIAN_POINT('',(-25.00000000018,-66.59999999983)); +#34621 = VECTOR('',#34622,1.); +#34622 = DIRECTION('',(-2.960594730768E-14,1.)); +#34623 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34624 = ADVANCED_FACE('',(#34625),#30326,.T.); +#34625 = FACE_BOUND('',#34626,.T.); +#34626 = EDGE_LOOP('',(#34627,#34628,#34629,#34652)); +#34627 = ORIENTED_EDGE('',*,*,#30960,.T.); +#34628 = ORIENTED_EDGE('',*,*,#30310,.T.); +#34629 = ORIENTED_EDGE('',*,*,#34630,.F.); +#34630 = EDGE_CURVE('',#34631,#30283,#34633,.T.); +#34631 = VERTEX_POINT('',#34632); +#34632 = CARTESIAN_POINT('',(31.000000000244,-58.59999173036,40.)); +#34633 = SURFACE_CURVE('',#34634,(#34638,#34645),.PCURVE_S1.); +#34634 = LINE('',#34635,#34636); +#34635 = CARTESIAN_POINT('',(31.000000000246,-61.5999917304,40.)); +#34636 = VECTOR('',#34637,1.); +#34637 = DIRECTION('',(-9.503220721166E-13,1.,-1.980689724944E-15)); +#34638 = PCURVE('',#30326,#34639); +#34639 = DEFINITIONAL_REPRESENTATION('',(#34640),#34644); +#34640 = LINE('',#34641,#34642); +#34641 = CARTESIAN_POINT('',(-3.000000000041,1.5)); +#34642 = VECTOR('',#34643,1.); +#34643 = DIRECTION('',(1.,0.)); +#34644 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34645 = PCURVE('',#30298,#34646); +#34646 = DEFINITIONAL_REPRESENTATION('',(#34647),#34651); +#34647 = LINE('',#34648,#34649); +#34648 = CARTESIAN_POINT('',(-33.00000000024,61.600000000358)); +#34649 = VECTOR('',#34650,1.); +#34650 = DIRECTION('',(9.503220721166E-13,-1.)); +#34651 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34652 = ORIENTED_EDGE('',*,*,#34653,.F.); +#34653 = EDGE_CURVE('',#30961,#34631,#34654,.T.); +#34654 = SURFACE_CURVE('',#34655,(#34659,#34666),.PCURVE_S1.); +#34655 = LINE('',#34656,#34657); +#34656 = CARTESIAN_POINT('',(31.000000000244,-58.59999173036,38.5)); +#34657 = VECTOR('',#34658,1.); +#34658 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34659 = PCURVE('',#30326,#34660); +#34660 = DEFINITIONAL_REPRESENTATION('',(#34661),#34665); +#34661 = LINE('',#34662,#34663); +#34662 = CARTESIAN_POINT('',(0.,0.)); +#34663 = VECTOR('',#34664,1.); +#34664 = DIRECTION('',(-1.980689724944E-15,1.)); +#34665 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34666 = PCURVE('',#30999,#34667); +#34667 = DEFINITIONAL_REPRESENTATION('',(#34668),#34672); +#34668 = LINE('',#34669,#34670); +#34669 = CARTESIAN_POINT('',(0.299999999924,3.301690486243E-28)); +#34670 = VECTOR('',#34671,1.); +#34671 = DIRECTION('',(-1.100563495693E-27,1.)); +#34672 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34673 = ADVANCED_FACE('',(#34674),#30999,.T.); +#34674 = FACE_BOUND('',#34675,.T.); +#34675 = EDGE_LOOP('',(#34676,#34677,#34678,#34679)); +#34676 = ORIENTED_EDGE('',*,*,#32645,.F.); +#34677 = ORIENTED_EDGE('',*,*,#30983,.T.); +#34678 = ORIENTED_EDGE('',*,*,#34653,.T.); +#34679 = ORIENTED_EDGE('',*,*,#34680,.F.); +#34680 = EDGE_CURVE('',#32646,#34631,#34681,.T.); +#34681 = SURFACE_CURVE('',#34682,(#34686,#34693),.PCURVE_S1.); +#34682 = LINE('',#34683,#34684); +#34683 = CARTESIAN_POINT('',(31.00000000016,-58.59999173036,40.)); +#34684 = VECTOR('',#34685,1.); +#34685 = DIRECTION('',(-1.,1.273055734871E-12,-1.100563495693E-27)); +#34686 = PCURVE('',#30999,#34687); +#34687 = DEFINITIONAL_REPRESENTATION('',(#34688),#34692); +#34688 = LINE('',#34689,#34690); +#34689 = CARTESIAN_POINT('',(0.300000000008,1.5)); +#34690 = VECTOR('',#34691,1.); +#34691 = DIRECTION('',(1.,0.)); +#34692 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34693 = PCURVE('',#30298,#34694); +#34694 = DEFINITIONAL_REPRESENTATION('',(#34695),#34699); +#34695 = LINE('',#34696,#34697); +#34696 = CARTESIAN_POINT('',(-33.00000000015,58.600000000318)); +#34697 = VECTOR('',#34698,1.); +#34698 = DIRECTION('',(1.,-1.273055734871E-12)); +#34699 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34700 = ADVANCED_FACE('',(#34701),#31170,.T.); +#34701 = FACE_BOUND('',#34702,.T.); +#34702 = EDGE_LOOP('',(#34703,#34704,#34727,#34748)); +#34703 = ORIENTED_EDGE('',*,*,#32365,.F.); +#34704 = ORIENTED_EDGE('',*,*,#34705,.F.); +#34705 = EDGE_CURVE('',#34706,#32338,#34708,.T.); +#34706 = VERTEX_POINT('',#34707); +#34707 = CARTESIAN_POINT('',(23.00000000009,-66.59999173055,40.)); +#34708 = SURFACE_CURVE('',#34709,(#34713,#34720),.PCURVE_S1.); +#34709 = LINE('',#34710,#34711); +#34710 = CARTESIAN_POINT('',(23.00000000009,-66.59999173046,40.)); +#34711 = VECTOR('',#34712,1.); +#34712 = DIRECTION('',(-2.398081735813E-12,-1.,1.980689724944E-15)); +#34713 = PCURVE('',#31170,#34714); +#34714 = DEFINITIONAL_REPRESENTATION('',(#34715),#34719); +#34715 = LINE('',#34716,#34717); +#34716 = CARTESIAN_POINT('',(-8.558900691507E-11,1.5)); +#34717 = VECTOR('',#34718,1.); +#34718 = DIRECTION('',(1.,0.)); +#34719 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34720 = PCURVE('',#30298,#34721); +#34721 = DEFINITIONAL_REPRESENTATION('',(#34722),#34726); +#34722 = LINE('',#34723,#34724); +#34723 = CARTESIAN_POINT('',(-25.00000000008,66.600000000422)); +#34724 = VECTOR('',#34725,1.); +#34725 = DIRECTION('',(2.398081735813E-12,1.)); +#34726 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34727 = ORIENTED_EDGE('',*,*,#34728,.F.); +#34728 = EDGE_CURVE('',#31155,#34706,#34729,.T.); +#34729 = SURFACE_CURVE('',#34730,(#34734,#34741),.PCURVE_S1.); +#34730 = LINE('',#34731,#34732); +#34731 = CARTESIAN_POINT('',(23.00000000009,-66.59999173055,38.5)); +#34732 = VECTOR('',#34733,1.); +#34733 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34734 = PCURVE('',#31170,#34735); +#34735 = DEFINITIONAL_REPRESENTATION('',(#34736),#34740); +#34736 = LINE('',#34737,#34738); +#34737 = CARTESIAN_POINT('',(0.,0.)); +#34738 = VECTOR('',#34739,1.); +#34739 = DIRECTION('',(1.980689724944E-15,1.)); +#34740 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34741 = PCURVE('',#31198,#34742); +#34742 = DEFINITIONAL_REPRESENTATION('',(#34743),#34747); +#34743 = LINE('',#34744,#34745); +#34744 = CARTESIAN_POINT('',(50.000000000006,-8.546704860714E-25)); +#34745 = VECTOR('',#34746,1.); +#34746 = DIRECTION('',(1.709340972143E-26,1.)); +#34747 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34748 = ORIENTED_EDGE('',*,*,#31154,.T.); +#34749 = ADVANCED_FACE('',(#34750),#31198,.T.); +#34750 = FACE_BOUND('',#34751,.T.); +#34751 = EDGE_LOOP('',(#34752,#34753,#34754,#34777)); +#34752 = ORIENTED_EDGE('',*,*,#31182,.T.); +#34753 = ORIENTED_EDGE('',*,*,#34728,.T.); +#34754 = ORIENTED_EDGE('',*,*,#34755,.F.); +#34755 = EDGE_CURVE('',#34756,#34706,#34758,.T.); +#34756 = VERTEX_POINT('',#34757); +#34757 = CARTESIAN_POINT('',(-26.99999999991,-66.59999173008,40.)); +#34758 = SURFACE_CURVE('',#34759,(#34763,#34770),.PCURVE_S1.); +#34759 = LINE('',#34760,#34761); +#34760 = CARTESIAN_POINT('',(-30.00000000006,-66.59999173005,40.)); +#34761 = VECTOR('',#34762,1.); +#34762 = DIRECTION('',(1.,-9.347443454171E-12,1.709340972143E-26)); +#34763 = PCURVE('',#31198,#34764); +#34764 = DEFINITIONAL_REPRESENTATION('',(#34765),#34769); +#34765 = LINE('',#34766,#34767); +#34766 = CARTESIAN_POINT('',(-3.000000000148,1.5)); +#34767 = VECTOR('',#34768,1.); +#34768 = DIRECTION('',(1.,0.)); +#34769 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34770 = PCURVE('',#30298,#34771); +#34771 = DEFINITIONAL_REPRESENTATION('',(#34772),#34776); +#34772 = LINE('',#34773,#34774); +#34773 = CARTESIAN_POINT('',(28.000000000066,66.600000000013)); +#34774 = VECTOR('',#34775,1.); +#34775 = DIRECTION('',(-1.,9.347443454171E-12)); +#34776 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34777 = ORIENTED_EDGE('',*,*,#34778,.F.); +#34778 = EDGE_CURVE('',#31183,#34756,#34779,.T.); +#34779 = SURFACE_CURVE('',#34780,(#34784,#34791),.PCURVE_S1.); +#34780 = LINE('',#34781,#34782); +#34781 = CARTESIAN_POINT('',(-26.99999999991,-66.59999173008,38.5)); +#34782 = VECTOR('',#34783,1.); +#34783 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34784 = PCURVE('',#31198,#34785); +#34785 = DEFINITIONAL_REPRESENTATION('',(#34786),#34790); +#34786 = LINE('',#34787,#34788); +#34787 = CARTESIAN_POINT('',(0.,0.)); +#34788 = VECTOR('',#34789,1.); +#34789 = DIRECTION('',(1.709340972143E-26,1.)); +#34790 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34791 = PCURVE('',#31226,#34792); +#34792 = DEFINITIONAL_REPRESENTATION('',(#34793),#34797); +#34793 = LINE('',#34794,#34795); +#34794 = CARTESIAN_POINT('',(0.299999999936,5.942069173565E-16)); +#34795 = VECTOR('',#34796,1.); +#34796 = DIRECTION('',(-1.980689724944E-15,1.)); +#34797 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34798 = ADVANCED_FACE('',(#34799),#31226,.T.); +#34799 = FACE_BOUND('',#34800,.T.); +#34800 = EDGE_LOOP('',(#34801,#34802,#34803,#34804)); +#34801 = ORIENTED_EDGE('',*,*,#32228,.F.); +#34802 = ORIENTED_EDGE('',*,*,#31210,.T.); +#34803 = ORIENTED_EDGE('',*,*,#34778,.T.); +#34804 = ORIENTED_EDGE('',*,*,#34805,.F.); +#34805 = EDGE_CURVE('',#32229,#34756,#34806,.T.); +#34806 = SURFACE_CURVE('',#34807,(#34811,#34818),.PCURVE_S1.); +#34807 = LINE('',#34808,#34809); +#34808 = CARTESIAN_POINT('',(-26.99999999991,-66.59999173012,40.)); +#34809 = VECTOR('',#34810,1.); +#34810 = DIRECTION('',(-5.181040783335E-14,1.,-1.980689724944E-15)); +#34811 = PCURVE('',#31226,#34812); +#34812 = DEFINITIONAL_REPRESENTATION('',(#34813),#34817); +#34813 = LINE('',#34814,#34815); +#34814 = CARTESIAN_POINT('',(0.299999999899,1.5)); +#34815 = VECTOR('',#34816,1.); +#34816 = DIRECTION('',(1.,0.)); +#34817 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34818 = PCURVE('',#30298,#34819); +#34819 = DEFINITIONAL_REPRESENTATION('',(#34820),#34824); +#34820 = LINE('',#34821,#34822); +#34821 = CARTESIAN_POINT('',(24.999999999918,66.600000000078)); +#34822 = VECTOR('',#34823,1.); +#34823 = DIRECTION('',(5.181040783335E-14,-1.)); +#34824 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34825 = ADVANCED_FACE('',(#34826),#30645,.T.); +#34826 = FACE_BOUND('',#34827,.T.); +#34827 = EDGE_LOOP('',(#34828,#34829,#34852,#34873)); +#34828 = ORIENTED_EDGE('',*,*,#30629,.F.); +#34829 = ORIENTED_EDGE('',*,*,#34830,.F.); +#34830 = EDGE_CURVE('',#34831,#30602,#34833,.T.); +#34831 = VERTEX_POINT('',#34832); +#34832 = CARTESIAN_POINT('',(-34.99999999979,-58.59999173031,40.)); +#34833 = SURFACE_CURVE('',#34834,(#34838,#34845),.PCURVE_S1.); +#34834 = LINE('',#34835,#34836); +#34835 = CARTESIAN_POINT('',(-34.99999999983,-58.59999173031,40.)); +#34836 = VECTOR('',#34837,1.); +#34837 = DIRECTION('',(-1.,1.776356839832E-13,1.069123743598E-27)); +#34838 = PCURVE('',#30645,#34839); +#34839 = DEFINITIONAL_REPRESENTATION('',(#34840),#34844); +#34840 = LINE('',#34841,#34842); +#34841 = CARTESIAN_POINT('',(1.603685615397E-27,1.5)); +#34842 = VECTOR('',#34843,1.); +#34843 = DIRECTION('',(1.,0.)); +#34844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34845 = PCURVE('',#30298,#34846); +#34846 = DEFINITIONAL_REPRESENTATION('',(#34847),#34851); +#34847 = LINE('',#34848,#34849); +#34848 = CARTESIAN_POINT('',(32.999999999833,58.600000000272)); +#34849 = VECTOR('',#34850,1.); +#34850 = DIRECTION('',(1.,-1.776356839832E-13)); +#34851 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34852 = ORIENTED_EDGE('',*,*,#34853,.F.); +#34853 = EDGE_CURVE('',#31310,#34831,#34854,.T.); +#34854 = SURFACE_CURVE('',#34855,(#34859,#34866),.PCURVE_S1.); +#34855 = LINE('',#34856,#34857); +#34856 = CARTESIAN_POINT('',(-34.99999999979,-58.59999173031,38.5)); +#34857 = VECTOR('',#34858,1.); +#34858 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34859 = PCURVE('',#30645,#34860); +#34860 = DEFINITIONAL_REPRESENTATION('',(#34861),#34865); +#34861 = LINE('',#34862,#34863); +#34862 = CARTESIAN_POINT('',(-4.084999005727E-11,4.367369429597E-38)); +#34863 = VECTOR('',#34864,1.); +#34864 = DIRECTION('',(1.069123743598E-27,1.)); +#34865 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34866 = PCURVE('',#31348,#34867); +#34867 = DEFINITIONAL_REPRESENTATION('',(#34868),#34872); +#34868 = LINE('',#34869,#34870); +#34869 = CARTESIAN_POINT('',(16.999999999988,6.580425768239E-14)); +#34870 = VECTOR('',#34871,1.); +#34871 = DIRECTION('',(1.980689724944E-15,1.)); +#34872 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34873 = ORIENTED_EDGE('',*,*,#31309,.T.); +#34874 = ADVANCED_FACE('',(#34875),#31348,.T.); +#34875 = FACE_BOUND('',#34876,.T.); +#34876 = EDGE_LOOP('',(#34877,#34878,#34879,#34902)); +#34877 = ORIENTED_EDGE('',*,*,#31332,.T.); +#34878 = ORIENTED_EDGE('',*,*,#34853,.T.); +#34879 = ORIENTED_EDGE('',*,*,#34880,.F.); +#34880 = EDGE_CURVE('',#34881,#34831,#34883,.T.); +#34881 = VERTEX_POINT('',#34882); +#34882 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,40.)); +#34883 = SURFACE_CURVE('',#34884,(#34888,#34895),.PCURVE_S1.); +#34884 = LINE('',#34885,#34886); +#34885 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,40.)); +#34886 = VECTOR('',#34887,1.); +#34887 = DIRECTION('',(9.121092769944E-12,-1.,1.980689724944E-15)); +#34888 = PCURVE('',#31348,#34889); +#34889 = DEFINITIONAL_REPRESENTATION('',(#34890),#34894); +#34890 = LINE('',#34891,#34892); +#34891 = CARTESIAN_POINT('',(2.971034587416E-15,1.5)); +#34892 = VECTOR('',#34893,1.); +#34893 = DIRECTION('',(1.,0.)); +#34894 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34895 = PCURVE('',#30298,#34896); +#34896 = DEFINITIONAL_REPRESENTATION('',(#34897),#34901); +#34897 = LINE('',#34898,#34899); +#34898 = CARTESIAN_POINT('',(32.999999999947,41.600000000284)); +#34899 = VECTOR('',#34900,1.); +#34900 = DIRECTION('',(-9.121092769944E-12,1.)); +#34901 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34902 = ORIENTED_EDGE('',*,*,#34903,.F.); +#34903 = EDGE_CURVE('',#31333,#34881,#34904,.T.); +#34904 = SURFACE_CURVE('',#34905,(#34909,#34916),.PCURVE_S1.); +#34905 = LINE('',#34906,#34907); +#34906 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,38.5)); +#34907 = VECTOR('',#34908,1.); +#34908 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34909 = PCURVE('',#31348,#34910); +#34910 = DEFINITIONAL_REPRESENTATION('',(#34911),#34915); +#34911 = LINE('',#34912,#34913); +#34912 = CARTESIAN_POINT('',(0.,0.)); +#34913 = VECTOR('',#34914,1.); +#34914 = DIRECTION('',(1.980689724944E-15,1.)); +#34915 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34916 = PCURVE('',#31376,#34917); +#34917 = DEFINITIONAL_REPRESENTATION('',(#34918),#34922); +#34918 = LINE('',#34919,#34920); +#34919 = CARTESIAN_POINT('',(10.00000000013,-5.232040729368E-28)); +#34920 = VECTOR('',#34921,1.); +#34921 = DIRECTION('',(5.2320407293E-29,1.)); +#34922 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34923 = ADVANCED_FACE('',(#34924),#31376,.T.); +#34924 = FACE_BOUND('',#34925,.T.); +#34925 = EDGE_LOOP('',(#34926,#34927,#34928,#34951)); +#34926 = ORIENTED_EDGE('',*,*,#31360,.F.); +#34927 = ORIENTED_EDGE('',*,*,#34903,.T.); +#34928 = ORIENTED_EDGE('',*,*,#34929,.F.); +#34929 = EDGE_CURVE('',#34930,#34881,#34932,.T.); +#34930 = VERTEX_POINT('',#34931); +#34931 = CARTESIAN_POINT('',(-24.99999999981,-41.59999173033,40.)); +#34932 = SURFACE_CURVE('',#34933,(#34937,#34944),.PCURVE_S1.); +#34933 = LINE('',#34934,#34935); +#34934 = CARTESIAN_POINT('',(-34.99999999994,-41.59999173033,40.)); +#34935 = VECTOR('',#34936,1.); +#34936 = DIRECTION('',(-1.,6.910028105177E-13,5.2320407293E-29)); +#34937 = PCURVE('',#31376,#34938); +#34938 = DEFINITIONAL_REPRESENTATION('',(#34939),#34943); +#34939 = LINE('',#34940,#34941); +#34940 = CARTESIAN_POINT('',(10.00000000013,1.5)); +#34941 = VECTOR('',#34942,1.); +#34942 = DIRECTION('',(1.,0.)); +#34943 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34944 = PCURVE('',#30298,#34945); +#34945 = DEFINITIONAL_REPRESENTATION('',(#34946),#34950); +#34946 = LINE('',#34947,#34948); +#34947 = CARTESIAN_POINT('',(32.999999999947,41.600000000284)); +#34948 = VECTOR('',#34949,1.); +#34949 = DIRECTION('',(1.,-6.910028105177E-13)); +#34950 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34951 = ORIENTED_EDGE('',*,*,#34952,.F.); +#34952 = EDGE_CURVE('',#31361,#34930,#34953,.T.); +#34953 = SURFACE_CURVE('',#34954,(#34958,#34965),.PCURVE_S1.); +#34954 = LINE('',#34955,#34956); +#34955 = CARTESIAN_POINT('',(-24.99999999981,-41.59999173033,38.5)); +#34956 = VECTOR('',#34957,1.); +#34957 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#34958 = PCURVE('',#31376,#34959); +#34959 = DEFINITIONAL_REPRESENTATION('',(#34960),#34964); +#34960 = LINE('',#34961,#34962); +#34961 = CARTESIAN_POINT('',(0.,0.)); +#34962 = VECTOR('',#34963,1.); +#34963 = DIRECTION('',(5.2320407293E-29,1.)); +#34964 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34965 = PCURVE('',#31404,#34966); +#34966 = DEFINITIONAL_REPRESENTATION('',(#34967),#34971); +#34967 = LINE('',#34968,#34969); +#34968 = CARTESIAN_POINT('',(83.200000000033,-6.531740210901E-14)); +#34969 = VECTOR('',#34970,1.); +#34970 = DIRECTION('',(1.980689724944E-15,1.)); +#34971 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34972 = ADVANCED_FACE('',(#34973),#31404,.T.); +#34973 = FACE_BOUND('',#34974,.T.); +#34974 = EDGE_LOOP('',(#34975,#34976,#34977,#35000)); +#34975 = ORIENTED_EDGE('',*,*,#31388,.T.); +#34976 = ORIENTED_EDGE('',*,*,#34952,.T.); +#34977 = ORIENTED_EDGE('',*,*,#34978,.F.); +#34978 = EDGE_CURVE('',#34979,#34930,#34981,.T.); +#34979 = VERTEX_POINT('',#34980); +#34980 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,40.)); +#34981 = SURFACE_CURVE('',#34982,(#34986,#34993),.PCURVE_S1.); +#34982 = LINE('',#34983,#34984); +#34983 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,40.)); +#34984 = VECTOR('',#34985,1.); +#34985 = DIRECTION('',(-7.105427357611E-14,-1.,1.980689724944E-15)); +#34986 = PCURVE('',#31404,#34987); +#34987 = DEFINITIONAL_REPRESENTATION('',(#34988),#34992); +#34988 = LINE('',#34989,#34990); +#34989 = CARTESIAN_POINT('',(2.971034587416E-15,1.5)); +#34990 = VECTOR('',#34991,1.); +#34991 = DIRECTION('',(1.,0.)); +#34992 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#34993 = PCURVE('',#30298,#34994); +#34994 = DEFINITIONAL_REPRESENTATION('',(#34995),#34999); +#34995 = LINE('',#34996,#34997); +#34996 = CARTESIAN_POINT('',(22.999999999817,-41.59999999974)); +#34997 = VECTOR('',#34998,1.); +#34998 = DIRECTION('',(7.105427357611E-14,1.)); +#34999 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35000 = ORIENTED_EDGE('',*,*,#35001,.F.); +#35001 = EDGE_CURVE('',#31389,#34979,#35002,.T.); +#35002 = SURFACE_CURVE('',#35003,(#35007,#35014),.PCURVE_S1.); +#35003 = LINE('',#35004,#35005); +#35004 = CARTESIAN_POINT('',(-24.99999999981,41.600008269695,38.5)); +#35005 = VECTOR('',#35006,1.); +#35006 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#35007 = PCURVE('',#31404,#35008); +#35008 = DEFINITIONAL_REPRESENTATION('',(#35009),#35013); +#35009 = LINE('',#35010,#35011); +#35010 = CARTESIAN_POINT('',(0.,0.)); +#35011 = VECTOR('',#35012,1.); +#35012 = DIRECTION('',(1.980689724944E-15,1.)); +#35013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35014 = PCURVE('',#31432,#35015); +#35015 = DEFINITIONAL_REPRESENTATION('',(#35016),#35020); +#35016 = LINE('',#35017,#35018); +#35017 = CARTESIAN_POINT('',(10.000000000234,3.822910400397E-28)); +#35018 = VECTOR('',#35019,1.); +#35019 = DIRECTION('',(-3.822910400307E-29,1.)); +#35020 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35021 = ADVANCED_FACE('',(#35022),#31432,.T.); +#35022 = FACE_BOUND('',#35023,.T.); +#35023 = EDGE_LOOP('',(#35024,#35025,#35026,#35049)); +#35024 = ORIENTED_EDGE('',*,*,#31416,.T.); +#35025 = ORIENTED_EDGE('',*,*,#35001,.T.); +#35026 = ORIENTED_EDGE('',*,*,#35027,.F.); +#35027 = EDGE_CURVE('',#35028,#34979,#35030,.T.); +#35028 = VERTEX_POINT('',#35029); +#35029 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,40.)); +#35030 = SURFACE_CURVE('',#35031,(#35035,#35042),.PCURVE_S1.); +#35031 = LINE('',#35032,#35033); +#35032 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,40.)); +#35033 = VECTOR('',#35034,1.); +#35034 = DIRECTION('',(1.,-6.98108237868E-13,-3.822910400307E-29)); +#35035 = PCURVE('',#31432,#35036); +#35036 = DEFINITIONAL_REPRESENTATION('',(#35037),#35041); +#35037 = LINE('',#35038,#35039); +#35038 = CARTESIAN_POINT('',(-5.734365600461E-29,1.5)); +#35039 = VECTOR('',#35040,1.); +#35040 = DIRECTION('',(1.,0.)); +#35041 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35042 = PCURVE('',#30298,#35043); +#35043 = DEFINITIONAL_REPRESENTATION('',(#35044),#35048); +#35044 = LINE('',#35045,#35046); +#35045 = CARTESIAN_POINT('',(33.000000000051,-41.59999999974)); +#35046 = VECTOR('',#35047,1.); +#35047 = DIRECTION('',(-1.,6.98108237868E-13)); +#35048 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35049 = ORIENTED_EDGE('',*,*,#35050,.F.); +#35050 = EDGE_CURVE('',#31417,#35028,#35051,.T.); +#35051 = SURFACE_CURVE('',#35052,(#35056,#35063),.PCURVE_S1.); +#35052 = LINE('',#35053,#35054); +#35053 = CARTESIAN_POINT('',(-35.00000000004,41.600008269702,38.5)); +#35054 = VECTOR('',#35055,1.); +#35055 = DIRECTION('',(4.484155085839E-44,-7.171696191935E-87,1.)); +#35056 = PCURVE('',#31432,#35057); +#35057 = DEFINITIONAL_REPRESENTATION('',(#35058),#35062); +#35058 = LINE('',#35059,#35060); +#35059 = CARTESIAN_POINT('',(0.,0.)); +#35060 = VECTOR('',#35061,1.); +#35061 = DIRECTION('',(-3.822910400307E-29,1.)); +#35062 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35063 = PCURVE('',#31460,#35064); +#35064 = DEFINITIONAL_REPRESENTATION('',(#35065),#35069); +#35065 = LINE('',#35066,#35067); +#35066 = CARTESIAN_POINT('',(17.000000000043,7.290968503988E-14)); +#35067 = VECTOR('',#35068,1.); +#35068 = DIRECTION('',(1.980689724944E-15,1.)); +#35069 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35070 = ADVANCED_FACE('',(#35071),#31460,.T.); +#35071 = FACE_BOUND('',#35072,.T.); +#35072 = EDGE_LOOP('',(#35073,#35074,#35075,#35096)); +#35073 = ORIENTED_EDGE('',*,*,#31444,.T.); +#35074 = ORIENTED_EDGE('',*,*,#35050,.T.); +#35075 = ORIENTED_EDGE('',*,*,#35076,.F.); +#35076 = EDGE_CURVE('',#33081,#35028,#35077,.T.); +#35077 = SURFACE_CURVE('',#35078,(#35082,#35089),.PCURVE_S1.); +#35078 = LINE('',#35079,#35080); +#35079 = CARTESIAN_POINT('',(-34.99999999985,61.600008269706,40.)); +#35080 = VECTOR('',#35081,1.); +#35081 = DIRECTION('',(-9.703571279827E-12,-1.,1.980689724944E-15)); +#35082 = PCURVE('',#31460,#35083); +#35083 = DEFINITIONAL_REPRESENTATION('',(#35084),#35088); +#35084 = LINE('',#35085,#35086); +#35085 = CARTESIAN_POINT('',(-2.999999999961,1.5)); +#35086 = VECTOR('',#35087,1.); +#35087 = DIRECTION('',(1.,0.)); +#35088 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35089 = PCURVE('',#30298,#35090); +#35090 = DEFINITIONAL_REPRESENTATION('',(#35091),#35095); +#35091 = LINE('',#35092,#35093); +#35092 = CARTESIAN_POINT('',(32.999999999857,-61.59999999975)); +#35093 = VECTOR('',#35094,1.); +#35094 = DIRECTION('',(9.703571279827E-12,1.)); +#35095 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#35096 = ORIENTED_EDGE('',*,*,#33080,.F.); +#35097 = ADVANCED_FACE('',(#35098,#35128,#35134,#35137,#35140,#35143, + #35146,#35149),#30298,.T.); +#35098 = FACE_BOUND('',#35099,.T.); +#35099 = EDGE_LOOP('',(#35100,#35101,#35102,#35103,#35104,#35105,#35106, + #35107,#35108,#35109,#35110,#35111,#35112,#35113,#35114,#35115, + #35116,#35117,#35118,#35119,#35120,#35121,#35122,#35123,#35124, + #35125,#35126,#35127)); +#35100 = ORIENTED_EDGE('',*,*,#33525,.T.); +#35101 = ORIENTED_EDGE('',*,*,#33500,.T.); +#35102 = ORIENTED_EDGE('',*,*,#33372,.T.); +#35103 = ORIENTED_EDGE('',*,*,#33103,.T.); +#35104 = ORIENTED_EDGE('',*,*,#35076,.T.); +#35105 = ORIENTED_EDGE('',*,*,#35027,.T.); +#35106 = ORIENTED_EDGE('',*,*,#34978,.T.); +#35107 = ORIENTED_EDGE('',*,*,#34929,.T.); +#35108 = ORIENTED_EDGE('',*,*,#34880,.T.); +#35109 = ORIENTED_EDGE('',*,*,#34830,.T.); +#35110 = ORIENTED_EDGE('',*,*,#33759,.T.); +#35111 = ORIENTED_EDGE('',*,*,#33734,.T.); +#35112 = ORIENTED_EDGE('',*,*,#33660,.T.); +#35113 = ORIENTED_EDGE('',*,*,#34805,.T.); +#35114 = ORIENTED_EDGE('',*,*,#34755,.T.); +#35115 = ORIENTED_EDGE('',*,*,#34705,.T.); +#35116 = ORIENTED_EDGE('',*,*,#33953,.T.); +#35117 = ORIENTED_EDGE('',*,*,#34027,.T.); +#35118 = ORIENTED_EDGE('',*,*,#34052,.T.); +#35119 = ORIENTED_EDGE('',*,*,#34680,.T.); +#35120 = ORIENTED_EDGE('',*,*,#34630,.T.); +#35121 = ORIENTED_EDGE('',*,*,#30282,.T.); +#35122 = ORIENTED_EDGE('',*,*,#33793,.T.); +#35123 = ORIENTED_EDGE('',*,*,#33867,.T.); +#35124 = ORIENTED_EDGE('',*,*,#33892,.T.); +#35125 = ORIENTED_EDGE('',*,*,#34604,.T.); +#35126 = ORIENTED_EDGE('',*,*,#34554,.T.); +#35127 = ORIENTED_EDGE('',*,*,#32926,.T.); +#35128 = FACE_BOUND('',#35129,.T.); +#35129 = EDGE_LOOP('',(#35130,#35131,#35132,#35133)); +#35130 = ORIENTED_EDGE('',*,*,#34257,.T.); +#35131 = ORIENTED_EDGE('',*,*,#34208,.T.); +#35132 = ORIENTED_EDGE('',*,*,#34159,.T.); +#35133 = ORIENTED_EDGE('',*,*,#34110,.T.); +#35134 = FACE_BOUND('',#35135,.T.); +#35135 = EDGE_LOOP('',(#35136)); +#35136 = ORIENTED_EDGE('',*,*,#34307,.T.); +#35137 = FACE_BOUND('',#35138,.T.); +#35138 = EDGE_LOOP('',(#35139)); +#35139 = ORIENTED_EDGE('',*,*,#34361,.T.); +#35140 = FACE_BOUND('',#35141,.T.); +#35141 = EDGE_LOOP('',(#35142)); +#35142 = ORIENTED_EDGE('',*,*,#34415,.T.); +#35143 = FACE_BOUND('',#35144,.T.); +#35144 = EDGE_LOOP('',(#35145)); +#35145 = ORIENTED_EDGE('',*,*,#34469,.T.); +#35146 = FACE_BOUND('',#35147,.T.); +#35147 = EDGE_LOOP('',(#35148)); +#35148 = ORIENTED_EDGE('',*,*,#34523,.T.); +#35149 = FACE_BOUND('',#35150,.T.); +#35150 = EDGE_LOOP('',(#35151,#35152,#35153,#35154)); +#35151 = ORIENTED_EDGE('',*,*,#33200,.T.); +#35152 = ORIENTED_EDGE('',*,*,#33347,.T.); +#35153 = ORIENTED_EDGE('',*,*,#33298,.T.); +#35154 = ORIENTED_EDGE('',*,*,#33249,.T.); +#35155 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#35159)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#35156,#35157,#35158)) +REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#35156 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#35157 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#35158 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#35159 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#35156, + 'distance_accuracy_value','confusion accuracy'); +#35160 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#35161,#35163); +#35161 = ( REPRESENTATION_RELATIONSHIP('','',#30120,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#35162) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#35162 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#35163 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item', + #35164); +#35164 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('5','DeskPad','',#5,#30115,$); +#35165 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#30117)); +#35166 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',( + #35167),#30102); +#35167 = STYLED_ITEM('color',(#35168),#26702); +#35168 = PRESENTATION_STYLE_ASSIGNMENT((#35169)); +#35169 = SURFACE_STYLE_USAGE(.BOTH.,#35170); +#35170 = SURFACE_SIDE_STYLE('',(#35171)); +#35171 = SURFACE_STYLE_FILL_AREA(#35172); +#35172 = FILL_AREA_STYLE('',(#35173)); +#35173 = FILL_AREA_STYLE_COLOUR('',#35174); +#35174 = COLOUR_RGB('',0.27999999963,0.27999999963,0.299999996101); +#35175 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',( + #35176),#35155); +#35176 = STYLED_ITEM('color',(#35177),#30121); +#35177 = PRESENTATION_STYLE_ASSIGNMENT((#35178)); +#35178 = SURFACE_STYLE_USAGE(.BOTH.,#35179); +#35179 = SURFACE_SIDE_STYLE('',(#35180)); +#35180 = SURFACE_STYLE_FILL_AREA(#35181); +#35181 = FILL_AREA_STYLE('',(#35182)); +#35182 = FILL_AREA_STYLE_COLOUR('',#35183); +#35183 = COLOUR_RGB('',0.649999988539,0.500000003429,0.27999999963); +#35184 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',( + #35185),#2579); +#35185 = STYLED_ITEM('color',(#35186),#49); +#35186 = PRESENTATION_STYLE_ASSIGNMENT((#35187)); +#35187 = SURFACE_STYLE_USAGE(.BOTH.,#35188); +#35188 = SURFACE_SIDE_STYLE('',(#35189)); +#35189 = SURFACE_STYLE_FILL_AREA(#35190); +#35190 = FILL_AREA_STYLE('',(#35191)); +#35191 = FILL_AREA_STYLE_COLOUR('',#35192); +#35192 = COLOUR_RGB('',7.999999887273E-02,0.599999994755,0.720000003324 + ); +#35193 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',( + #35194),#26683); +#35194 = STYLED_ITEM('color',(#35195),#20343); +#35195 = PRESENTATION_STYLE_ASSIGNMENT((#35196)); +#35196 = SURFACE_STYLE_USAGE(.BOTH.,#35197); +#35197 = SURFACE_SIDE_STYLE('',(#35198)); +#35198 = SURFACE_STYLE_FILL_AREA(#35199); +#35199 = FILL_AREA_STYLE('',(#35200)); +#35200 = FILL_AREA_STYLE_COLOUR('',#35201); +#35201 = COLOUR_RGB('',0.480000004686,0.480000004686,0.500000003429); +#35202 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',( + #35203),#20324); +#35203 = STYLED_ITEM('color',(#35204),#2598); +#35204 = PRESENTATION_STYLE_ASSIGNMENT((#35205)); +#35205 = SURFACE_STYLE_USAGE(.BOTH.,#35206); +#35206 = SURFACE_SIDE_STYLE('',(#35207)); +#35207 = SURFACE_STYLE_FILL_AREA(#35208); +#35208 = FILL_AREA_STYLE('',(#35209)); +#35209 = FILL_AREA_STYLE_COLOUR('',#35210); +#35210 = COLOUR_RGB('',0.350000000377,0.350000000377,0.380000002513); +ENDSEC; +END-ISO-10303-21; diff --git a/3d_models/parts/hd1370a/bottom-cover/BottomCover_Fusion.step b/3d_models/parts/hd1370a/bottom-cover/BottomCover_Fusion.step new file mode 100644 index 0000000..6cf6343 --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/BottomCover_Fusion.step @@ -0,0 +1,1214 @@ +ISO-10303-21; +HEADER; +/* Generated by software containing ST-Developer + * from STEP Tools, Inc. (www.steptools.com) + */ + +FILE_DESCRIPTION( +/* description */ (''), +/* implementation_level */ '2;1'); + +FILE_NAME( +/* name */ 'BottomCover_Fusion.step', +/* time_stamp */ '2026-09-25T20:10:25-07:00', +/* author */ (''), +/* organization */ (''), +/* preprocessor_version */ 'ST-DEVELOPER v20.2', +/* originating_system */ 'Autodesk Translation Framework v15.15.0.0', +/* authorisation */ ''); + +FILE_SCHEMA (('AUTOMOTIVE_DESIGN { 1 0 10303 214 3 1 1 }')); +ENDSEC; + +DATA; +#10=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#13),#1133); +#11=SHAPE_REPRESENTATION_RELATIONSHIP('SRR','None',#1140,#12); +#12=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#14),#1132); +#13=STYLED_ITEM('',(#1149),#14); +#14=MANIFOLD_SOLID_BREP('BottomCover',#657); +#15=FACE_BOUND('',#83,.T.); +#16=FACE_BOUND('',#86,.T.); +#17=FACE_BOUND('',#89,.T.); +#18=FACE_BOUND('',#92,.T.); +#19=FACE_BOUND('',#120,.T.); +#20=FACE_BOUND('',#121,.T.); +#21=FACE_BOUND('',#122,.T.); +#22=FACE_BOUND('',#123,.T.); +#23=FACE_BOUND('',#125,.T.); +#24=FACE_BOUND('',#126,.T.); +#25=FACE_BOUND('',#127,.T.); +#26=FACE_BOUND('',#128,.T.); +#27=PLANE('',#674); +#28=PLANE('',#679); +#29=PLANE('',#684); +#30=PLANE('',#689); +#31=PLANE('',#699); +#32=PLANE('',#703); +#33=PLANE('',#707); +#34=PLANE('',#708); +#35=PLANE('',#709); +#36=PLANE('',#713); +#37=PLANE('',#717); +#38=PLANE('',#721); +#39=PLANE('',#725); +#40=PLANE('',#729); +#41=PLANE('',#733); +#42=PLANE('',#737); +#43=PLANE('',#741); +#44=PLANE('',#742); +#45=FACE_OUTER_BOUND('',#81,.T.); +#46=FACE_OUTER_BOUND('',#82,.T.); +#47=FACE_OUTER_BOUND('',#84,.T.); +#48=FACE_OUTER_BOUND('',#85,.T.); +#49=FACE_OUTER_BOUND('',#87,.T.); +#50=FACE_OUTER_BOUND('',#88,.T.); +#51=FACE_OUTER_BOUND('',#90,.T.); +#52=FACE_OUTER_BOUND('',#91,.T.); +#53=FACE_OUTER_BOUND('',#93,.T.); +#54=FACE_OUTER_BOUND('',#94,.T.); +#55=FACE_OUTER_BOUND('',#95,.T.); +#56=FACE_OUTER_BOUND('',#96,.T.); +#57=FACE_OUTER_BOUND('',#97,.T.); +#58=FACE_OUTER_BOUND('',#98,.T.); +#59=FACE_OUTER_BOUND('',#99,.T.); +#60=FACE_OUTER_BOUND('',#100,.T.); +#61=FACE_OUTER_BOUND('',#101,.T.); +#62=FACE_OUTER_BOUND('',#102,.T.); +#63=FACE_OUTER_BOUND('',#103,.T.); +#64=FACE_OUTER_BOUND('',#104,.T.); +#65=FACE_OUTER_BOUND('',#105,.T.); +#66=FACE_OUTER_BOUND('',#106,.T.); +#67=FACE_OUTER_BOUND('',#107,.T.); +#68=FACE_OUTER_BOUND('',#108,.T.); +#69=FACE_OUTER_BOUND('',#109,.T.); +#70=FACE_OUTER_BOUND('',#110,.T.); +#71=FACE_OUTER_BOUND('',#111,.T.); +#72=FACE_OUTER_BOUND('',#112,.T.); +#73=FACE_OUTER_BOUND('',#113,.T.); +#74=FACE_OUTER_BOUND('',#114,.T.); +#75=FACE_OUTER_BOUND('',#115,.T.); +#76=FACE_OUTER_BOUND('',#116,.T.); +#77=FACE_OUTER_BOUND('',#117,.T.); +#78=FACE_OUTER_BOUND('',#118,.T.); +#79=FACE_OUTER_BOUND('',#119,.T.); +#80=FACE_OUTER_BOUND('',#124,.T.); +#81=EDGE_LOOP('',(#423,#424,#425,#426)); +#82=EDGE_LOOP('',(#427)); +#83=EDGE_LOOP('',(#428)); +#84=EDGE_LOOP('',(#429,#430,#431,#432)); +#85=EDGE_LOOP('',(#433)); +#86=EDGE_LOOP('',(#434)); +#87=EDGE_LOOP('',(#435,#436,#437,#438)); +#88=EDGE_LOOP('',(#439)); +#89=EDGE_LOOP('',(#440)); +#90=EDGE_LOOP('',(#441,#442,#443,#444)); +#91=EDGE_LOOP('',(#445)); +#92=EDGE_LOOP('',(#446)); +#93=EDGE_LOOP('',(#447,#448,#449,#450)); +#94=EDGE_LOOP('',(#451,#452,#453,#454)); +#95=EDGE_LOOP('',(#455,#456,#457,#458)); +#96=EDGE_LOOP('',(#459,#460,#461,#462)); +#97=EDGE_LOOP('',(#463,#464,#465,#466)); +#98=EDGE_LOOP('',(#467,#468,#469,#470)); +#99=EDGE_LOOP('',(#471,#472,#473,#474)); +#100=EDGE_LOOP('',(#475,#476,#477,#478)); +#101=EDGE_LOOP('',(#479,#480,#481,#482)); +#102=EDGE_LOOP('',(#483,#484,#485,#486)); +#103=EDGE_LOOP('',(#487,#488,#489,#490)); +#104=EDGE_LOOP('',(#491,#492,#493,#494)); +#105=EDGE_LOOP('',(#495,#496,#497,#498)); +#106=EDGE_LOOP('',(#499,#500,#501,#502)); +#107=EDGE_LOOP('',(#503,#504,#505,#506)); +#108=EDGE_LOOP('',(#507,#508,#509,#510)); +#109=EDGE_LOOP('',(#511,#512,#513,#514)); +#110=EDGE_LOOP('',(#515,#516,#517,#518)); +#111=EDGE_LOOP('',(#519,#520,#521,#522)); +#112=EDGE_LOOP('',(#523,#524,#525,#526)); +#113=EDGE_LOOP('',(#527,#528,#529,#530)); +#114=EDGE_LOOP('',(#531,#532,#533,#534)); +#115=EDGE_LOOP('',(#535,#536,#537,#538)); +#116=EDGE_LOOP('',(#539,#540,#541,#542)); +#117=EDGE_LOOP('',(#543,#544,#545,#546)); +#118=EDGE_LOOP('',(#547,#548,#549,#550)); +#119=EDGE_LOOP('',(#551,#552,#553,#554,#555,#556,#557,#558,#559,#560,#561, +#562,#563,#564,#565,#566,#567,#568,#569,#570,#571,#572)); +#120=EDGE_LOOP('',(#573)); +#121=EDGE_LOOP('',(#574)); +#122=EDGE_LOOP('',(#575)); +#123=EDGE_LOOP('',(#576)); +#124=EDGE_LOOP('',(#577,#578,#579,#580,#581,#582,#583,#584,#585,#586,#587, +#588,#589,#590,#591,#592,#593,#594,#595,#596,#597,#598)); +#125=EDGE_LOOP('',(#599)); +#126=EDGE_LOOP('',(#600)); +#127=EDGE_LOOP('',(#601)); +#128=EDGE_LOOP('',(#602)); +#129=LINE('',#948,#183); +#130=LINE('',#957,#184); +#131=LINE('',#966,#185); +#132=LINE('',#975,#186); +#133=LINE('',#982,#187); +#134=LINE('',#986,#188); +#135=LINE('',#990,#189); +#136=LINE('',#994,#190); +#137=LINE('',#999,#191); +#138=LINE('',#1001,#192); +#139=LINE('',#1003,#193); +#140=LINE('',#1004,#194); +#141=LINE('',#1010,#195); +#142=LINE('',#1013,#196); +#143=LINE('',#1015,#197); +#144=LINE('',#1016,#198); +#145=LINE('',#1022,#199); +#146=LINE('',#1025,#200); +#147=LINE('',#1027,#201); +#148=LINE('',#1028,#202); +#149=LINE('',#1031,#203); +#150=LINE('',#1033,#204); +#151=LINE('',#1034,#205); +#152=LINE('',#1037,#206); +#153=LINE('',#1039,#207); +#154=LINE('',#1040,#208); +#155=LINE('',#1046,#209); +#156=LINE('',#1049,#210); +#157=LINE('',#1051,#211); +#158=LINE('',#1052,#212); +#159=LINE('',#1058,#213); +#160=LINE('',#1061,#214); +#161=LINE('',#1063,#215); +#162=LINE('',#1064,#216); +#163=LINE('',#1070,#217); +#164=LINE('',#1073,#218); +#165=LINE('',#1075,#219); +#166=LINE('',#1076,#220); +#167=LINE('',#1082,#221); +#168=LINE('',#1085,#222); +#169=LINE('',#1087,#223); +#170=LINE('',#1088,#224); +#171=LINE('',#1094,#225); +#172=LINE('',#1097,#226); +#173=LINE('',#1099,#227); +#174=LINE('',#1100,#228); +#175=LINE('',#1106,#229); +#176=LINE('',#1109,#230); +#177=LINE('',#1111,#231); +#178=LINE('',#1112,#232); +#179=LINE('',#1118,#233); +#180=LINE('',#1121,#234); +#181=LINE('',#1123,#235); +#182=LINE('',#1124,#236); +#183=VECTOR('',#749,0.215); +#184=VECTOR('',#760,0.215); +#185=VECTOR('',#771,0.215); +#186=VECTOR('',#782,0.215); +#187=VECTOR('',#791,0.115); +#188=VECTOR('',#796,0.115); +#189=VECTOR('',#801,0.115); +#190=VECTOR('',#806,0.115); +#191=VECTOR('',#811,1.); +#192=VECTOR('',#812,1.); +#193=VECTOR('',#813,1.); +#194=VECTOR('',#814,1.); +#195=VECTOR('',#821,1.); +#196=VECTOR('',#824,1.); +#197=VECTOR('',#825,1.); +#198=VECTOR('',#826,1.); +#199=VECTOR('',#833,1.); +#200=VECTOR('',#836,1.); +#201=VECTOR('',#837,1.); +#202=VECTOR('',#838,1.); +#203=VECTOR('',#841,1.); +#204=VECTOR('',#842,1.); +#205=VECTOR('',#843,1.); +#206=VECTOR('',#846,1.); +#207=VECTOR('',#847,1.); +#208=VECTOR('',#848,1.); +#209=VECTOR('',#855,1.); +#210=VECTOR('',#858,1.); +#211=VECTOR('',#859,1.); +#212=VECTOR('',#860,1.); +#213=VECTOR('',#867,1.); +#214=VECTOR('',#870,1.); +#215=VECTOR('',#871,1.); +#216=VECTOR('',#872,1.); +#217=VECTOR('',#879,1.); +#218=VECTOR('',#882,1.); +#219=VECTOR('',#883,1.); +#220=VECTOR('',#884,1.); +#221=VECTOR('',#891,1.); +#222=VECTOR('',#894,1.); +#223=VECTOR('',#895,1.); +#224=VECTOR('',#896,1.); +#225=VECTOR('',#903,1.); +#226=VECTOR('',#906,1.); +#227=VECTOR('',#907,1.); +#228=VECTOR('',#908,1.); +#229=VECTOR('',#915,1.); +#230=VECTOR('',#918,1.); +#231=VECTOR('',#919,1.); +#232=VECTOR('',#920,1.); +#233=VECTOR('',#927,1.); +#234=VECTOR('',#930,1.); +#235=VECTOR('',#931,1.); +#236=VECTOR('',#932,1.); +#237=CIRCLE('',#672,0.215); +#238=CIRCLE('',#673,0.215); +#239=CIRCLE('',#675,0.115); +#240=CIRCLE('',#677,0.215); +#241=CIRCLE('',#678,0.215); +#242=CIRCLE('',#680,0.115); +#243=CIRCLE('',#682,0.215); +#244=CIRCLE('',#683,0.215); +#245=CIRCLE('',#685,0.115); +#246=CIRCLE('',#687,0.215); +#247=CIRCLE('',#688,0.215); +#248=CIRCLE('',#690,0.115); +#249=CIRCLE('',#692,0.115); +#250=CIRCLE('',#694,0.115); +#251=CIRCLE('',#696,0.115); +#252=CIRCLE('',#698,0.115); +#253=CIRCLE('',#701,0.100000000063692); +#254=CIRCLE('',#702,0.100000000063692); +#255=CIRCLE('',#705,0.100000000063691); +#256=CIRCLE('',#706,0.100000000063691); +#257=CIRCLE('',#711,0.100000000063692); +#258=CIRCLE('',#712,0.100000000063692); +#259=CIRCLE('',#715,0.100000000063692); +#260=CIRCLE('',#716,0.100000000063692); +#261=CIRCLE('',#719,0.299999999849652); +#262=CIRCLE('',#720,0.299999999849652); +#263=CIRCLE('',#723,0.299999999849652); +#264=CIRCLE('',#724,0.299999999849652); +#265=CIRCLE('',#727,0.29999999984965); +#266=CIRCLE('',#728,0.29999999984965); +#267=CIRCLE('',#731,0.300000000020361); +#268=CIRCLE('',#732,0.300000000020361); +#269=CIRCLE('',#735,0.299999999849651); +#270=CIRCLE('',#736,0.299999999849651); +#271=CIRCLE('',#739,0.299999999849652); +#272=CIRCLE('',#740,0.299999999849652); +#273=VERTEX_POINT('',#945); +#274=VERTEX_POINT('',#947); +#275=VERTEX_POINT('',#951); +#276=VERTEX_POINT('',#954); +#277=VERTEX_POINT('',#956); +#278=VERTEX_POINT('',#960); +#279=VERTEX_POINT('',#963); +#280=VERTEX_POINT('',#965); +#281=VERTEX_POINT('',#969); +#282=VERTEX_POINT('',#972); +#283=VERTEX_POINT('',#974); +#284=VERTEX_POINT('',#978); +#285=VERTEX_POINT('',#981); +#286=VERTEX_POINT('',#985); +#287=VERTEX_POINT('',#989); +#288=VERTEX_POINT('',#993); +#289=VERTEX_POINT('',#997); +#290=VERTEX_POINT('',#998); +#291=VERTEX_POINT('',#1000); +#292=VERTEX_POINT('',#1002); +#293=VERTEX_POINT('',#1006); +#294=VERTEX_POINT('',#1008); +#295=VERTEX_POINT('',#1012); +#296=VERTEX_POINT('',#1014); +#297=VERTEX_POINT('',#1018); +#298=VERTEX_POINT('',#1020); +#299=VERTEX_POINT('',#1024); +#300=VERTEX_POINT('',#1026); +#301=VERTEX_POINT('',#1030); +#302=VERTEX_POINT('',#1032); +#303=VERTEX_POINT('',#1036); +#304=VERTEX_POINT('',#1038); +#305=VERTEX_POINT('',#1042); +#306=VERTEX_POINT('',#1044); +#307=VERTEX_POINT('',#1048); +#308=VERTEX_POINT('',#1050); +#309=VERTEX_POINT('',#1054); +#310=VERTEX_POINT('',#1056); +#311=VERTEX_POINT('',#1060); +#312=VERTEX_POINT('',#1062); +#313=VERTEX_POINT('',#1066); +#314=VERTEX_POINT('',#1068); +#315=VERTEX_POINT('',#1072); +#316=VERTEX_POINT('',#1074); +#317=VERTEX_POINT('',#1078); +#318=VERTEX_POINT('',#1080); +#319=VERTEX_POINT('',#1084); +#320=VERTEX_POINT('',#1086); +#321=VERTEX_POINT('',#1090); +#322=VERTEX_POINT('',#1092); +#323=VERTEX_POINT('',#1096); +#324=VERTEX_POINT('',#1098); +#325=VERTEX_POINT('',#1102); +#326=VERTEX_POINT('',#1104); +#327=VERTEX_POINT('',#1108); +#328=VERTEX_POINT('',#1110); +#329=VERTEX_POINT('',#1114); +#330=VERTEX_POINT('',#1116); +#331=VERTEX_POINT('',#1120); +#332=VERTEX_POINT('',#1122); +#333=EDGE_CURVE('',#273,#273,#237,.T.); +#334=EDGE_CURVE('',#273,#274,#129,.T.); +#335=EDGE_CURVE('',#274,#274,#238,.T.); +#336=EDGE_CURVE('',#275,#275,#239,.T.); +#337=EDGE_CURVE('',#276,#276,#240,.T.); +#338=EDGE_CURVE('',#276,#277,#130,.T.); +#339=EDGE_CURVE('',#277,#277,#241,.T.); +#340=EDGE_CURVE('',#278,#278,#242,.T.); +#341=EDGE_CURVE('',#279,#279,#243,.T.); +#342=EDGE_CURVE('',#279,#280,#131,.T.); +#343=EDGE_CURVE('',#280,#280,#244,.T.); +#344=EDGE_CURVE('',#281,#281,#245,.T.); +#345=EDGE_CURVE('',#282,#282,#246,.T.); +#346=EDGE_CURVE('',#282,#283,#132,.T.); +#347=EDGE_CURVE('',#283,#283,#247,.T.); +#348=EDGE_CURVE('',#284,#284,#248,.T.); +#349=EDGE_CURVE('',#275,#285,#133,.T.); +#350=EDGE_CURVE('',#285,#285,#249,.T.); +#351=EDGE_CURVE('',#278,#286,#134,.T.); +#352=EDGE_CURVE('',#286,#286,#250,.T.); +#353=EDGE_CURVE('',#281,#287,#135,.T.); +#354=EDGE_CURVE('',#287,#287,#251,.T.); +#355=EDGE_CURVE('',#284,#288,#136,.T.); +#356=EDGE_CURVE('',#288,#288,#252,.T.); +#357=EDGE_CURVE('',#289,#290,#137,.T.); +#358=EDGE_CURVE('',#289,#291,#138,.T.); +#359=EDGE_CURVE('',#292,#291,#139,.T.); +#360=EDGE_CURVE('',#290,#292,#140,.T.); +#361=EDGE_CURVE('',#290,#293,#253,.T.); +#362=EDGE_CURVE('',#294,#292,#254,.T.); +#363=EDGE_CURVE('',#293,#294,#141,.T.); +#364=EDGE_CURVE('',#293,#295,#142,.T.); +#365=EDGE_CURVE('',#296,#294,#143,.T.); +#366=EDGE_CURVE('',#295,#296,#144,.T.); +#367=EDGE_CURVE('',#295,#297,#255,.T.); +#368=EDGE_CURVE('',#298,#296,#256,.T.); +#369=EDGE_CURVE('',#297,#298,#145,.T.); +#370=EDGE_CURVE('',#297,#299,#146,.T.); +#371=EDGE_CURVE('',#300,#298,#147,.T.); +#372=EDGE_CURVE('',#299,#300,#148,.T.); +#373=EDGE_CURVE('',#299,#301,#149,.T.); +#374=EDGE_CURVE('',#302,#300,#150,.T.); +#375=EDGE_CURVE('',#301,#302,#151,.T.); +#376=EDGE_CURVE('',#301,#303,#152,.T.); +#377=EDGE_CURVE('',#304,#302,#153,.T.); +#378=EDGE_CURVE('',#303,#304,#154,.T.); +#379=EDGE_CURVE('',#303,#305,#257,.T.); +#380=EDGE_CURVE('',#306,#304,#258,.T.); +#381=EDGE_CURVE('',#305,#306,#155,.T.); +#382=EDGE_CURVE('',#305,#307,#156,.T.); +#383=EDGE_CURVE('',#308,#306,#157,.T.); +#384=EDGE_CURVE('',#307,#308,#158,.T.); +#385=EDGE_CURVE('',#307,#309,#259,.T.); +#386=EDGE_CURVE('',#310,#308,#260,.T.); +#387=EDGE_CURVE('',#309,#310,#159,.T.); +#388=EDGE_CURVE('',#309,#311,#160,.T.); +#389=EDGE_CURVE('',#312,#310,#161,.T.); +#390=EDGE_CURVE('',#311,#312,#162,.T.); +#391=EDGE_CURVE('',#313,#311,#261,.T.); +#392=EDGE_CURVE('',#314,#312,#262,.T.); +#393=EDGE_CURVE('',#313,#314,#163,.T.); +#394=EDGE_CURVE('',#313,#315,#164,.T.); +#395=EDGE_CURVE('',#316,#314,#165,.T.); +#396=EDGE_CURVE('',#315,#316,#166,.T.); +#397=EDGE_CURVE('',#317,#315,#263,.T.); +#398=EDGE_CURVE('',#318,#316,#264,.T.); +#399=EDGE_CURVE('',#317,#318,#167,.T.); +#400=EDGE_CURVE('',#317,#319,#168,.T.); +#401=EDGE_CURVE('',#320,#318,#169,.T.); +#402=EDGE_CURVE('',#319,#320,#170,.T.); +#403=EDGE_CURVE('',#321,#319,#265,.T.); +#404=EDGE_CURVE('',#322,#320,#266,.T.); +#405=EDGE_CURVE('',#321,#322,#171,.T.); +#406=EDGE_CURVE('',#321,#323,#172,.T.); +#407=EDGE_CURVE('',#324,#322,#173,.T.); +#408=EDGE_CURVE('',#323,#324,#174,.T.); +#409=EDGE_CURVE('',#325,#323,#267,.T.); +#410=EDGE_CURVE('',#326,#324,#268,.T.); +#411=EDGE_CURVE('',#325,#326,#175,.T.); +#412=EDGE_CURVE('',#325,#327,#176,.T.); +#413=EDGE_CURVE('',#328,#326,#177,.T.); +#414=EDGE_CURVE('',#327,#328,#178,.T.); +#415=EDGE_CURVE('',#329,#327,#269,.T.); +#416=EDGE_CURVE('',#330,#328,#270,.T.); +#417=EDGE_CURVE('',#329,#330,#179,.T.); +#418=EDGE_CURVE('',#329,#331,#180,.T.); +#419=EDGE_CURVE('',#332,#330,#181,.T.); +#420=EDGE_CURVE('',#331,#332,#182,.T.); +#421=EDGE_CURVE('',#289,#331,#271,.T.); +#422=EDGE_CURVE('',#291,#332,#272,.T.); +#423=ORIENTED_EDGE('',*,*,#333,.F.); +#424=ORIENTED_EDGE('',*,*,#334,.T.); +#425=ORIENTED_EDGE('',*,*,#335,.T.); +#426=ORIENTED_EDGE('',*,*,#334,.F.); +#427=ORIENTED_EDGE('',*,*,#335,.F.); +#428=ORIENTED_EDGE('',*,*,#336,.F.); +#429=ORIENTED_EDGE('',*,*,#337,.F.); +#430=ORIENTED_EDGE('',*,*,#338,.T.); +#431=ORIENTED_EDGE('',*,*,#339,.T.); +#432=ORIENTED_EDGE('',*,*,#338,.F.); +#433=ORIENTED_EDGE('',*,*,#339,.F.); +#434=ORIENTED_EDGE('',*,*,#340,.F.); +#435=ORIENTED_EDGE('',*,*,#341,.F.); +#436=ORIENTED_EDGE('',*,*,#342,.T.); +#437=ORIENTED_EDGE('',*,*,#343,.T.); +#438=ORIENTED_EDGE('',*,*,#342,.F.); +#439=ORIENTED_EDGE('',*,*,#343,.F.); +#440=ORIENTED_EDGE('',*,*,#344,.F.); +#441=ORIENTED_EDGE('',*,*,#345,.F.); +#442=ORIENTED_EDGE('',*,*,#346,.T.); +#443=ORIENTED_EDGE('',*,*,#347,.T.); +#444=ORIENTED_EDGE('',*,*,#346,.F.); +#445=ORIENTED_EDGE('',*,*,#347,.F.); +#446=ORIENTED_EDGE('',*,*,#348,.F.); +#447=ORIENTED_EDGE('',*,*,#336,.T.); +#448=ORIENTED_EDGE('',*,*,#349,.T.); +#449=ORIENTED_EDGE('',*,*,#350,.F.); +#450=ORIENTED_EDGE('',*,*,#349,.F.); +#451=ORIENTED_EDGE('',*,*,#340,.T.); +#452=ORIENTED_EDGE('',*,*,#351,.T.); +#453=ORIENTED_EDGE('',*,*,#352,.F.); +#454=ORIENTED_EDGE('',*,*,#351,.F.); +#455=ORIENTED_EDGE('',*,*,#344,.T.); +#456=ORIENTED_EDGE('',*,*,#353,.T.); +#457=ORIENTED_EDGE('',*,*,#354,.F.); +#458=ORIENTED_EDGE('',*,*,#353,.F.); +#459=ORIENTED_EDGE('',*,*,#348,.T.); +#460=ORIENTED_EDGE('',*,*,#355,.T.); +#461=ORIENTED_EDGE('',*,*,#356,.F.); +#462=ORIENTED_EDGE('',*,*,#355,.F.); +#463=ORIENTED_EDGE('',*,*,#357,.F.); +#464=ORIENTED_EDGE('',*,*,#358,.T.); +#465=ORIENTED_EDGE('',*,*,#359,.F.); +#466=ORIENTED_EDGE('',*,*,#360,.F.); +#467=ORIENTED_EDGE('',*,*,#361,.F.); +#468=ORIENTED_EDGE('',*,*,#360,.T.); +#469=ORIENTED_EDGE('',*,*,#362,.F.); +#470=ORIENTED_EDGE('',*,*,#363,.F.); +#471=ORIENTED_EDGE('',*,*,#364,.F.); +#472=ORIENTED_EDGE('',*,*,#363,.T.); +#473=ORIENTED_EDGE('',*,*,#365,.F.); +#474=ORIENTED_EDGE('',*,*,#366,.F.); +#475=ORIENTED_EDGE('',*,*,#367,.F.); +#476=ORIENTED_EDGE('',*,*,#366,.T.); +#477=ORIENTED_EDGE('',*,*,#368,.F.); +#478=ORIENTED_EDGE('',*,*,#369,.F.); +#479=ORIENTED_EDGE('',*,*,#370,.F.); +#480=ORIENTED_EDGE('',*,*,#369,.T.); +#481=ORIENTED_EDGE('',*,*,#371,.F.); +#482=ORIENTED_EDGE('',*,*,#372,.F.); +#483=ORIENTED_EDGE('',*,*,#373,.F.); +#484=ORIENTED_EDGE('',*,*,#372,.T.); +#485=ORIENTED_EDGE('',*,*,#374,.F.); +#486=ORIENTED_EDGE('',*,*,#375,.F.); +#487=ORIENTED_EDGE('',*,*,#376,.F.); +#488=ORIENTED_EDGE('',*,*,#375,.T.); +#489=ORIENTED_EDGE('',*,*,#377,.F.); +#490=ORIENTED_EDGE('',*,*,#378,.F.); +#491=ORIENTED_EDGE('',*,*,#379,.F.); +#492=ORIENTED_EDGE('',*,*,#378,.T.); +#493=ORIENTED_EDGE('',*,*,#380,.F.); +#494=ORIENTED_EDGE('',*,*,#381,.F.); +#495=ORIENTED_EDGE('',*,*,#382,.F.); +#496=ORIENTED_EDGE('',*,*,#381,.T.); +#497=ORIENTED_EDGE('',*,*,#383,.F.); +#498=ORIENTED_EDGE('',*,*,#384,.F.); +#499=ORIENTED_EDGE('',*,*,#385,.F.); +#500=ORIENTED_EDGE('',*,*,#384,.T.); +#501=ORIENTED_EDGE('',*,*,#386,.F.); +#502=ORIENTED_EDGE('',*,*,#387,.F.); +#503=ORIENTED_EDGE('',*,*,#388,.F.); +#504=ORIENTED_EDGE('',*,*,#387,.T.); +#505=ORIENTED_EDGE('',*,*,#389,.F.); +#506=ORIENTED_EDGE('',*,*,#390,.F.); +#507=ORIENTED_EDGE('',*,*,#391,.T.); +#508=ORIENTED_EDGE('',*,*,#390,.T.); +#509=ORIENTED_EDGE('',*,*,#392,.F.); +#510=ORIENTED_EDGE('',*,*,#393,.F.); +#511=ORIENTED_EDGE('',*,*,#394,.F.); +#512=ORIENTED_EDGE('',*,*,#393,.T.); +#513=ORIENTED_EDGE('',*,*,#395,.F.); +#514=ORIENTED_EDGE('',*,*,#396,.F.); +#515=ORIENTED_EDGE('',*,*,#397,.T.); +#516=ORIENTED_EDGE('',*,*,#396,.T.); +#517=ORIENTED_EDGE('',*,*,#398,.F.); +#518=ORIENTED_EDGE('',*,*,#399,.F.); +#519=ORIENTED_EDGE('',*,*,#400,.F.); +#520=ORIENTED_EDGE('',*,*,#399,.T.); +#521=ORIENTED_EDGE('',*,*,#401,.F.); +#522=ORIENTED_EDGE('',*,*,#402,.F.); +#523=ORIENTED_EDGE('',*,*,#403,.T.); +#524=ORIENTED_EDGE('',*,*,#402,.T.); +#525=ORIENTED_EDGE('',*,*,#404,.F.); +#526=ORIENTED_EDGE('',*,*,#405,.F.); +#527=ORIENTED_EDGE('',*,*,#406,.F.); +#528=ORIENTED_EDGE('',*,*,#405,.T.); +#529=ORIENTED_EDGE('',*,*,#407,.F.); +#530=ORIENTED_EDGE('',*,*,#408,.F.); +#531=ORIENTED_EDGE('',*,*,#409,.T.); +#532=ORIENTED_EDGE('',*,*,#408,.T.); +#533=ORIENTED_EDGE('',*,*,#410,.F.); +#534=ORIENTED_EDGE('',*,*,#411,.F.); +#535=ORIENTED_EDGE('',*,*,#412,.F.); +#536=ORIENTED_EDGE('',*,*,#411,.T.); +#537=ORIENTED_EDGE('',*,*,#413,.F.); +#538=ORIENTED_EDGE('',*,*,#414,.F.); +#539=ORIENTED_EDGE('',*,*,#415,.T.); +#540=ORIENTED_EDGE('',*,*,#414,.T.); +#541=ORIENTED_EDGE('',*,*,#416,.F.); +#542=ORIENTED_EDGE('',*,*,#417,.F.); +#543=ORIENTED_EDGE('',*,*,#418,.F.); +#544=ORIENTED_EDGE('',*,*,#417,.T.); +#545=ORIENTED_EDGE('',*,*,#419,.F.); +#546=ORIENTED_EDGE('',*,*,#420,.F.); +#547=ORIENTED_EDGE('',*,*,#421,.T.); +#548=ORIENTED_EDGE('',*,*,#420,.T.); +#549=ORIENTED_EDGE('',*,*,#422,.F.); +#550=ORIENTED_EDGE('',*,*,#358,.F.); +#551=ORIENTED_EDGE('',*,*,#422,.T.); +#552=ORIENTED_EDGE('',*,*,#419,.T.); +#553=ORIENTED_EDGE('',*,*,#416,.T.); +#554=ORIENTED_EDGE('',*,*,#413,.T.); +#555=ORIENTED_EDGE('',*,*,#410,.T.); +#556=ORIENTED_EDGE('',*,*,#407,.T.); +#557=ORIENTED_EDGE('',*,*,#404,.T.); +#558=ORIENTED_EDGE('',*,*,#401,.T.); +#559=ORIENTED_EDGE('',*,*,#398,.T.); +#560=ORIENTED_EDGE('',*,*,#395,.T.); +#561=ORIENTED_EDGE('',*,*,#392,.T.); +#562=ORIENTED_EDGE('',*,*,#389,.T.); +#563=ORIENTED_EDGE('',*,*,#386,.T.); +#564=ORIENTED_EDGE('',*,*,#383,.T.); +#565=ORIENTED_EDGE('',*,*,#380,.T.); +#566=ORIENTED_EDGE('',*,*,#377,.T.); +#567=ORIENTED_EDGE('',*,*,#374,.T.); +#568=ORIENTED_EDGE('',*,*,#371,.T.); +#569=ORIENTED_EDGE('',*,*,#368,.T.); +#570=ORIENTED_EDGE('',*,*,#365,.T.); +#571=ORIENTED_EDGE('',*,*,#362,.T.); +#572=ORIENTED_EDGE('',*,*,#359,.T.); +#573=ORIENTED_EDGE('',*,*,#350,.T.); +#574=ORIENTED_EDGE('',*,*,#352,.T.); +#575=ORIENTED_EDGE('',*,*,#354,.T.); +#576=ORIENTED_EDGE('',*,*,#356,.T.); +#577=ORIENTED_EDGE('',*,*,#421,.F.); +#578=ORIENTED_EDGE('',*,*,#357,.T.); +#579=ORIENTED_EDGE('',*,*,#361,.T.); +#580=ORIENTED_EDGE('',*,*,#364,.T.); +#581=ORIENTED_EDGE('',*,*,#367,.T.); +#582=ORIENTED_EDGE('',*,*,#370,.T.); +#583=ORIENTED_EDGE('',*,*,#373,.T.); +#584=ORIENTED_EDGE('',*,*,#376,.T.); +#585=ORIENTED_EDGE('',*,*,#379,.T.); +#586=ORIENTED_EDGE('',*,*,#382,.T.); +#587=ORIENTED_EDGE('',*,*,#385,.T.); +#588=ORIENTED_EDGE('',*,*,#388,.T.); +#589=ORIENTED_EDGE('',*,*,#391,.F.); +#590=ORIENTED_EDGE('',*,*,#394,.T.); +#591=ORIENTED_EDGE('',*,*,#397,.F.); +#592=ORIENTED_EDGE('',*,*,#400,.T.); +#593=ORIENTED_EDGE('',*,*,#403,.F.); +#594=ORIENTED_EDGE('',*,*,#406,.T.); +#595=ORIENTED_EDGE('',*,*,#409,.F.); +#596=ORIENTED_EDGE('',*,*,#412,.T.); +#597=ORIENTED_EDGE('',*,*,#415,.F.); +#598=ORIENTED_EDGE('',*,*,#418,.T.); +#599=ORIENTED_EDGE('',*,*,#345,.T.); +#600=ORIENTED_EDGE('',*,*,#341,.T.); +#601=ORIENTED_EDGE('',*,*,#337,.T.); +#602=ORIENTED_EDGE('',*,*,#333,.T.); +#603=CYLINDRICAL_SURFACE('',#671,0.215); +#604=CYLINDRICAL_SURFACE('',#676,0.215); +#605=CYLINDRICAL_SURFACE('',#681,0.215); +#606=CYLINDRICAL_SURFACE('',#686,0.215); +#607=CYLINDRICAL_SURFACE('',#691,0.115); +#608=CYLINDRICAL_SURFACE('',#693,0.115); +#609=CYLINDRICAL_SURFACE('',#695,0.115); +#610=CYLINDRICAL_SURFACE('',#697,0.115); +#611=CYLINDRICAL_SURFACE('',#700,0.100000000063692); +#612=CYLINDRICAL_SURFACE('',#704,0.100000000063691); +#613=CYLINDRICAL_SURFACE('',#710,0.100000000063692); +#614=CYLINDRICAL_SURFACE('',#714,0.100000000063692); +#615=CYLINDRICAL_SURFACE('',#718,0.299999999849652); +#616=CYLINDRICAL_SURFACE('',#722,0.299999999849652); +#617=CYLINDRICAL_SURFACE('',#726,0.29999999984965); +#618=CYLINDRICAL_SURFACE('',#730,0.300000000020361); +#619=CYLINDRICAL_SURFACE('',#734,0.299999999849651); +#620=CYLINDRICAL_SURFACE('',#738,0.299999999849652); +#621=ADVANCED_FACE('',(#45),#603,.F.); +#622=ADVANCED_FACE('',(#46,#15),#27,.F.); +#623=ADVANCED_FACE('',(#47),#604,.F.); +#624=ADVANCED_FACE('',(#48,#16),#28,.F.); +#625=ADVANCED_FACE('',(#49),#605,.F.); +#626=ADVANCED_FACE('',(#50,#17),#29,.F.); +#627=ADVANCED_FACE('',(#51),#606,.F.); +#628=ADVANCED_FACE('',(#52,#18),#30,.F.); +#629=ADVANCED_FACE('',(#53),#607,.F.); +#630=ADVANCED_FACE('',(#54),#608,.F.); +#631=ADVANCED_FACE('',(#55),#609,.F.); +#632=ADVANCED_FACE('',(#56),#610,.F.); +#633=ADVANCED_FACE('',(#57),#31,.T.); +#634=ADVANCED_FACE('',(#58),#611,.F.); +#635=ADVANCED_FACE('',(#59),#32,.T.); +#636=ADVANCED_FACE('',(#60),#612,.F.); +#637=ADVANCED_FACE('',(#61),#33,.T.); +#638=ADVANCED_FACE('',(#62),#34,.T.); +#639=ADVANCED_FACE('',(#63),#35,.T.); +#640=ADVANCED_FACE('',(#64),#613,.F.); +#641=ADVANCED_FACE('',(#65),#36,.T.); +#642=ADVANCED_FACE('',(#66),#614,.F.); +#643=ADVANCED_FACE('',(#67),#37,.T.); +#644=ADVANCED_FACE('',(#68),#615,.T.); +#645=ADVANCED_FACE('',(#69),#38,.T.); +#646=ADVANCED_FACE('',(#70),#616,.T.); +#647=ADVANCED_FACE('',(#71),#39,.T.); +#648=ADVANCED_FACE('',(#72),#617,.T.); +#649=ADVANCED_FACE('',(#73),#40,.T.); +#650=ADVANCED_FACE('',(#74),#618,.T.); +#651=ADVANCED_FACE('',(#75),#41,.T.); +#652=ADVANCED_FACE('',(#76),#619,.T.); +#653=ADVANCED_FACE('',(#77),#42,.T.); +#654=ADVANCED_FACE('',(#78),#620,.T.); +#655=ADVANCED_FACE('',(#79,#19,#20,#21,#22),#43,.T.); +#656=ADVANCED_FACE('',(#80,#23,#24,#25,#26),#44,.F.); +#657=CLOSED_SHELL('',(#621,#622,#623,#624,#625,#626,#627,#628,#629,#630, +#631,#632,#633,#634,#635,#636,#637,#638,#639,#640,#641,#642,#643,#644,#645, +#646,#647,#648,#649,#650,#651,#652,#653,#654,#655,#656)); +#658=DERIVED_UNIT_ELEMENT(#660,1.); +#659=DERIVED_UNIT_ELEMENT(#1135,-3.); +#660=( +MASS_UNIT() +NAMED_UNIT(*) +SI_UNIT(.KILO.,.GRAM.) +); +#661=DERIVED_UNIT((#658,#659)); +#662=MEASURE_REPRESENTATION_ITEM('density measure', +POSITIVE_RATIO_MEASURE(7850.),#661); +#663=PROPERTY_DEFINITION_REPRESENTATION(#668,#665); +#664=PROPERTY_DEFINITION_REPRESENTATION(#669,#666); +#665=REPRESENTATION('material name',(#667),#1132); +#666=REPRESENTATION('density',(#662),#1132); +#667=DESCRIPTIVE_REPRESENTATION_ITEM('Steel','Steel'); +#668=PROPERTY_DEFINITION('material property','material name',#1142); +#669=PROPERTY_DEFINITION('material property','density of part',#1142); +#670=AXIS2_PLACEMENT_3D('',#943,#743,#744); +#671=AXIS2_PLACEMENT_3D('',#944,#745,#746); +#672=AXIS2_PLACEMENT_3D('',#946,#747,#748); +#673=AXIS2_PLACEMENT_3D('',#949,#750,#751); +#674=AXIS2_PLACEMENT_3D('',#950,#752,#753); +#675=AXIS2_PLACEMENT_3D('',#952,#754,#755); +#676=AXIS2_PLACEMENT_3D('',#953,#756,#757); +#677=AXIS2_PLACEMENT_3D('',#955,#758,#759); +#678=AXIS2_PLACEMENT_3D('',#958,#761,#762); +#679=AXIS2_PLACEMENT_3D('',#959,#763,#764); +#680=AXIS2_PLACEMENT_3D('',#961,#765,#766); +#681=AXIS2_PLACEMENT_3D('',#962,#767,#768); +#682=AXIS2_PLACEMENT_3D('',#964,#769,#770); +#683=AXIS2_PLACEMENT_3D('',#967,#772,#773); +#684=AXIS2_PLACEMENT_3D('',#968,#774,#775); +#685=AXIS2_PLACEMENT_3D('',#970,#776,#777); +#686=AXIS2_PLACEMENT_3D('',#971,#778,#779); +#687=AXIS2_PLACEMENT_3D('',#973,#780,#781); +#688=AXIS2_PLACEMENT_3D('',#976,#783,#784); +#689=AXIS2_PLACEMENT_3D('',#977,#785,#786); +#690=AXIS2_PLACEMENT_3D('',#979,#787,#788); +#691=AXIS2_PLACEMENT_3D('',#980,#789,#790); +#692=AXIS2_PLACEMENT_3D('',#983,#792,#793); +#693=AXIS2_PLACEMENT_3D('',#984,#794,#795); +#694=AXIS2_PLACEMENT_3D('',#987,#797,#798); +#695=AXIS2_PLACEMENT_3D('',#988,#799,#800); +#696=AXIS2_PLACEMENT_3D('',#991,#802,#803); +#697=AXIS2_PLACEMENT_3D('',#992,#804,#805); +#698=AXIS2_PLACEMENT_3D('',#995,#807,#808); +#699=AXIS2_PLACEMENT_3D('',#996,#809,#810); +#700=AXIS2_PLACEMENT_3D('',#1005,#815,#816); +#701=AXIS2_PLACEMENT_3D('',#1007,#817,#818); +#702=AXIS2_PLACEMENT_3D('',#1009,#819,#820); +#703=AXIS2_PLACEMENT_3D('',#1011,#822,#823); +#704=AXIS2_PLACEMENT_3D('',#1017,#827,#828); +#705=AXIS2_PLACEMENT_3D('',#1019,#829,#830); +#706=AXIS2_PLACEMENT_3D('',#1021,#831,#832); +#707=AXIS2_PLACEMENT_3D('',#1023,#834,#835); +#708=AXIS2_PLACEMENT_3D('',#1029,#839,#840); +#709=AXIS2_PLACEMENT_3D('',#1035,#844,#845); +#710=AXIS2_PLACEMENT_3D('',#1041,#849,#850); +#711=AXIS2_PLACEMENT_3D('',#1043,#851,#852); +#712=AXIS2_PLACEMENT_3D('',#1045,#853,#854); +#713=AXIS2_PLACEMENT_3D('',#1047,#856,#857); +#714=AXIS2_PLACEMENT_3D('',#1053,#861,#862); +#715=AXIS2_PLACEMENT_3D('',#1055,#863,#864); +#716=AXIS2_PLACEMENT_3D('',#1057,#865,#866); +#717=AXIS2_PLACEMENT_3D('',#1059,#868,#869); +#718=AXIS2_PLACEMENT_3D('',#1065,#873,#874); +#719=AXIS2_PLACEMENT_3D('',#1067,#875,#876); +#720=AXIS2_PLACEMENT_3D('',#1069,#877,#878); +#721=AXIS2_PLACEMENT_3D('',#1071,#880,#881); +#722=AXIS2_PLACEMENT_3D('',#1077,#885,#886); +#723=AXIS2_PLACEMENT_3D('',#1079,#887,#888); +#724=AXIS2_PLACEMENT_3D('',#1081,#889,#890); +#725=AXIS2_PLACEMENT_3D('',#1083,#892,#893); +#726=AXIS2_PLACEMENT_3D('',#1089,#897,#898); +#727=AXIS2_PLACEMENT_3D('',#1091,#899,#900); +#728=AXIS2_PLACEMENT_3D('',#1093,#901,#902); +#729=AXIS2_PLACEMENT_3D('',#1095,#904,#905); +#730=AXIS2_PLACEMENT_3D('',#1101,#909,#910); +#731=AXIS2_PLACEMENT_3D('',#1103,#911,#912); +#732=AXIS2_PLACEMENT_3D('',#1105,#913,#914); +#733=AXIS2_PLACEMENT_3D('',#1107,#916,#917); +#734=AXIS2_PLACEMENT_3D('',#1113,#921,#922); +#735=AXIS2_PLACEMENT_3D('',#1115,#923,#924); +#736=AXIS2_PLACEMENT_3D('',#1117,#925,#926); +#737=AXIS2_PLACEMENT_3D('',#1119,#928,#929); +#738=AXIS2_PLACEMENT_3D('',#1125,#933,#934); +#739=AXIS2_PLACEMENT_3D('',#1126,#935,#936); +#740=AXIS2_PLACEMENT_3D('',#1127,#937,#938); +#741=AXIS2_PLACEMENT_3D('',#1128,#939,#940); +#742=AXIS2_PLACEMENT_3D('',#1129,#941,#942); +#743=DIRECTION('axis',(0.,0.,1.)); +#744=DIRECTION('refdir',(1.,0.,0.)); +#745=DIRECTION('center_axis',(0.,0.,1.)); +#746=DIRECTION('ref_axis',(1.,0.,0.)); +#747=DIRECTION('center_axis',(0.,0.,1.)); +#748=DIRECTION('ref_axis',(1.,0.,0.)); +#749=DIRECTION('',(0.,0.,1.)); +#750=DIRECTION('center_axis',(0.,0.,1.)); +#751=DIRECTION('ref_axis',(1.,0.,0.)); +#752=DIRECTION('center_axis',(0.,0.,1.)); +#753=DIRECTION('ref_axis',(1.,0.,0.)); +#754=DIRECTION('center_axis',(0.,0.,-1.)); +#755=DIRECTION('ref_axis',(1.,0.,0.)); +#756=DIRECTION('center_axis',(0.,0.,1.)); +#757=DIRECTION('ref_axis',(1.,0.,0.)); +#758=DIRECTION('center_axis',(0.,0.,1.)); +#759=DIRECTION('ref_axis',(1.,0.,0.)); +#760=DIRECTION('',(0.,0.,1.)); +#761=DIRECTION('center_axis',(0.,0.,1.)); +#762=DIRECTION('ref_axis',(1.,0.,0.)); +#763=DIRECTION('center_axis',(0.,0.,1.)); +#764=DIRECTION('ref_axis',(1.,0.,0.)); +#765=DIRECTION('center_axis',(0.,0.,-1.)); +#766=DIRECTION('ref_axis',(1.,0.,0.)); +#767=DIRECTION('center_axis',(0.,0.,1.)); +#768=DIRECTION('ref_axis',(1.,0.,0.)); +#769=DIRECTION('center_axis',(0.,0.,1.)); +#770=DIRECTION('ref_axis',(1.,0.,0.)); +#771=DIRECTION('',(0.,0.,1.)); +#772=DIRECTION('center_axis',(0.,0.,1.)); +#773=DIRECTION('ref_axis',(1.,0.,0.)); +#774=DIRECTION('center_axis',(0.,0.,1.)); +#775=DIRECTION('ref_axis',(1.,0.,0.)); +#776=DIRECTION('center_axis',(0.,0.,-1.)); +#777=DIRECTION('ref_axis',(1.,0.,0.)); +#778=DIRECTION('center_axis',(0.,0.,1.)); +#779=DIRECTION('ref_axis',(1.,0.,0.)); +#780=DIRECTION('center_axis',(0.,0.,1.)); +#781=DIRECTION('ref_axis',(1.,0.,0.)); +#782=DIRECTION('',(0.,0.,1.)); +#783=DIRECTION('center_axis',(0.,0.,1.)); +#784=DIRECTION('ref_axis',(1.,0.,0.)); +#785=DIRECTION('center_axis',(0.,0.,1.)); +#786=DIRECTION('ref_axis',(1.,0.,0.)); +#787=DIRECTION('center_axis',(0.,0.,-1.)); +#788=DIRECTION('ref_axis',(1.,0.,0.)); +#789=DIRECTION('center_axis',(0.,0.,1.)); +#790=DIRECTION('ref_axis',(1.,0.,0.)); +#791=DIRECTION('',(0.,0.,1.)); +#792=DIRECTION('center_axis',(0.,0.,-1.)); +#793=DIRECTION('ref_axis',(1.,0.,0.)); +#794=DIRECTION('center_axis',(0.,0.,1.)); +#795=DIRECTION('ref_axis',(1.,0.,0.)); +#796=DIRECTION('',(0.,0.,1.)); +#797=DIRECTION('center_axis',(0.,0.,-1.)); +#798=DIRECTION('ref_axis',(1.,0.,0.)); +#799=DIRECTION('center_axis',(0.,0.,1.)); +#800=DIRECTION('ref_axis',(1.,0.,0.)); +#801=DIRECTION('',(0.,0.,1.)); +#802=DIRECTION('center_axis',(0.,0.,-1.)); +#803=DIRECTION('ref_axis',(1.,0.,0.)); +#804=DIRECTION('center_axis',(0.,0.,1.)); +#805=DIRECTION('ref_axis',(1.,0.,0.)); +#806=DIRECTION('',(0.,0.,1.)); +#807=DIRECTION('center_axis',(0.,0.,-1.)); +#808=DIRECTION('ref_axis',(1.,0.,0.)); +#809=DIRECTION('center_axis',(0.,1.,0.)); +#810=DIRECTION('ref_axis',(-1.,0.,0.)); +#811=DIRECTION('',(1.,0.,0.)); +#812=DIRECTION('',(0.,0.,1.)); +#813=DIRECTION('',(-1.,0.,0.)); +#814=DIRECTION('',(0.,0.,1.)); +#815=DIRECTION('center_axis',(0.,0.,1.)); +#816=DIRECTION('ref_axis',(6.36921626145487E-10,-1.,0.)); +#817=DIRECTION('center_axis',(0.,0.,1.)); +#818=DIRECTION('ref_axis',(6.36921626145487E-10,-1.,0.)); +#819=DIRECTION('center_axis',(0.,0.,-1.)); +#820=DIRECTION('ref_axis',(6.36921626145487E-10,-1.,0.)); +#821=DIRECTION('',(0.,0.,1.)); +#822=DIRECTION('center_axis',(-1.,0.,0.)); +#823=DIRECTION('ref_axis',(0.,-1.,0.)); +#824=DIRECTION('',(0.,1.,0.)); +#825=DIRECTION('',(0.,-1.,0.)); +#826=DIRECTION('',(0.,0.,1.)); +#827=DIRECTION('center_axis',(0.,0.,1.)); +#828=DIRECTION('ref_axis',(1.,6.36917185253397E-10,0.)); +#829=DIRECTION('center_axis',(0.,0.,1.)); +#830=DIRECTION('ref_axis',(1.,6.36917185253397E-10,0.)); +#831=DIRECTION('center_axis',(0.,0.,-1.)); +#832=DIRECTION('ref_axis',(1.,6.36917185253397E-10,0.)); +#833=DIRECTION('',(0.,0.,1.)); +#834=DIRECTION('center_axis',(0.,-1.,0.)); +#835=DIRECTION('ref_axis',(1.,0.,0.)); +#836=DIRECTION('',(-1.,0.,0.)); +#837=DIRECTION('',(1.,0.,0.)); +#838=DIRECTION('',(0.,0.,1.)); +#839=DIRECTION('center_axis',(-1.,0.,0.)); +#840=DIRECTION('ref_axis',(0.,-1.,0.)); +#841=DIRECTION('',(0.,1.,0.)); +#842=DIRECTION('',(0.,-1.,0.)); +#843=DIRECTION('',(0.,0.,1.)); +#844=DIRECTION('center_axis',(0.,1.,0.)); +#845=DIRECTION('ref_axis',(-1.,0.,0.)); +#846=DIRECTION('',(1.,0.,0.)); +#847=DIRECTION('',(-1.,0.,0.)); +#848=DIRECTION('',(0.,0.,1.)); +#849=DIRECTION('center_axis',(0.,0.,1.)); +#850=DIRECTION('ref_axis',(6.36912744361299E-10,-1.,0.)); +#851=DIRECTION('center_axis',(0.,0.,1.)); +#852=DIRECTION('ref_axis',(6.36912744361299E-10,-1.,0.)); +#853=DIRECTION('center_axis',(0.,0.,-1.)); +#854=DIRECTION('ref_axis',(6.36912744361299E-10,-1.,0.)); +#855=DIRECTION('',(0.,0.,1.)); +#856=DIRECTION('center_axis',(-1.,0.,0.)); +#857=DIRECTION('ref_axis',(0.,-1.,0.)); +#858=DIRECTION('',(0.,1.,0.)); +#859=DIRECTION('',(0.,-1.,0.)); +#860=DIRECTION('',(0.,0.,1.)); +#861=DIRECTION('center_axis',(0.,0.,1.)); +#862=DIRECTION('ref_axis',(1.,6.36921626145487E-10,0.)); +#863=DIRECTION('center_axis',(0.,0.,1.)); +#864=DIRECTION('ref_axis',(1.,6.36921626145487E-10,0.)); +#865=DIRECTION('center_axis',(0.,0.,-1.)); +#866=DIRECTION('ref_axis',(1.,6.36921626145487E-10,0.)); +#867=DIRECTION('',(0.,0.,1.)); +#868=DIRECTION('center_axis',(0.,-1.,0.)); +#869=DIRECTION('ref_axis',(1.,0.,0.)); +#870=DIRECTION('',(-1.,0.,0.)); +#871=DIRECTION('',(1.,0.,0.)); +#872=DIRECTION('',(0.,0.,1.)); +#873=DIRECTION('center_axis',(0.,0.,1.)); +#874=DIRECTION('ref_axis',(-1.,5.01160594756423E-10,0.)); +#875=DIRECTION('center_axis',(0.,0.,1.)); +#876=DIRECTION('ref_axis',(-1.,5.01160594756423E-10,0.)); +#877=DIRECTION('center_axis',(0.,0.,1.)); +#878=DIRECTION('ref_axis',(-1.,5.01160594756423E-10,0.)); +#879=DIRECTION('',(0.,0.,1.)); +#880=DIRECTION('center_axis',(-1.,0.,0.)); +#881=DIRECTION('ref_axis',(0.,-1.,0.)); +#882=DIRECTION('',(0.,1.,0.)); +#883=DIRECTION('',(0.,-1.,0.)); +#884=DIRECTION('',(0.,0.,1.)); +#885=DIRECTION('center_axis',(0.,0.,1.)); +#886=DIRECTION('ref_axis',(5.01162075053789E-10,1.,0.)); +#887=DIRECTION('center_axis',(0.,0.,1.)); +#888=DIRECTION('ref_axis',(5.01162075053789E-10,1.,0.)); +#889=DIRECTION('center_axis',(0.,0.,1.)); +#890=DIRECTION('ref_axis',(5.01162075053789E-10,1.,0.)); +#891=DIRECTION('',(0.,0.,1.)); +#892=DIRECTION('center_axis',(0.,1.,0.)); +#893=DIRECTION('ref_axis',(-1.,0.,0.)); +#894=DIRECTION('',(1.,0.,0.)); +#895=DIRECTION('',(-1.,0.,0.)); +#896=DIRECTION('',(0.,0.,1.)); +#897=DIRECTION('center_axis',(0.,0.,1.)); +#898=DIRECTION('ref_axis',(1.,-5.01160594756425E-10,0.)); +#899=DIRECTION('center_axis',(0.,0.,1.)); +#900=DIRECTION('ref_axis',(1.,-5.01160594756425E-10,0.)); +#901=DIRECTION('center_axis',(0.,0.,1.)); +#902=DIRECTION('ref_axis',(1.,-5.01160594756425E-10,0.)); +#903=DIRECTION('',(0.,0.,1.)); +#904=DIRECTION('center_axis',(1.,0.,0.)); +#905=DIRECTION('ref_axis',(0.,1.,0.)); +#906=DIRECTION('',(0.,-1.,0.)); +#907=DIRECTION('',(0.,1.,0.)); +#908=DIRECTION('',(0.,0.,1.)); +#909=DIRECTION('center_axis',(0.,0.,1.)); +#910=DIRECTION('ref_axis',(6.78701539367787E-11,-1.,0.)); +#911=DIRECTION('center_axis',(0.,0.,1.)); +#912=DIRECTION('ref_axis',(6.78701539367787E-11,-1.,0.)); +#913=DIRECTION('center_axis',(0.,0.,1.)); +#914=DIRECTION('ref_axis',(6.78701539367787E-11,-1.,0.)); +#915=DIRECTION('',(0.,0.,1.)); +#916=DIRECTION('center_axis',(0.,-1.,0.)); +#917=DIRECTION('ref_axis',(1.,0.,0.)); +#918=DIRECTION('',(-1.,0.,0.)); +#919=DIRECTION('',(1.,0.,0.)); +#920=DIRECTION('',(0.,0.,1.)); +#921=DIRECTION('center_axis',(0.,0.,1.)); +#922=DIRECTION('ref_axis',(-1.,5.0115763416169E-10,0.)); +#923=DIRECTION('center_axis',(0.,0.,1.)); +#924=DIRECTION('ref_axis',(-1.,5.0115763416169E-10,0.)); +#925=DIRECTION('center_axis',(0.,0.,1.)); +#926=DIRECTION('ref_axis',(-1.,5.0115763416169E-10,0.)); +#927=DIRECTION('',(0.,0.,1.)); +#928=DIRECTION('center_axis',(-1.,0.,0.)); +#929=DIRECTION('ref_axis',(0.,-1.,0.)); +#930=DIRECTION('',(0.,1.,0.)); +#931=DIRECTION('',(0.,-1.,0.)); +#932=DIRECTION('',(0.,0.,1.)); +#933=DIRECTION('center_axis',(0.,0.,1.)); +#934=DIRECTION('ref_axis',(5.01160594756423E-10,1.,0.)); +#935=DIRECTION('center_axis',(0.,0.,1.)); +#936=DIRECTION('ref_axis',(5.01160594756423E-10,1.,0.)); +#937=DIRECTION('center_axis',(0.,0.,1.)); +#938=DIRECTION('ref_axis',(5.01160594756423E-10,1.,0.)); +#939=DIRECTION('center_axis',(0.,0.,1.)); +#940=DIRECTION('ref_axis',(1.,0.,0.)); +#941=DIRECTION('center_axis',(0.,0.,1.)); +#942=DIRECTION('ref_axis',(1.,0.,0.)); +#943=CARTESIAN_POINT('',(0.,0.,0.)); +#944=CARTESIAN_POINT('Origin',(-3.,6.16,0.)); +#945=CARTESIAN_POINT('',(-3.215,6.16,0.)); +#946=CARTESIAN_POINT('Origin',(-3.,6.16,0.)); +#947=CARTESIAN_POINT('',(-3.215,6.16,0.23)); +#948=CARTESIAN_POINT('',(-3.215,6.16,0.)); +#949=CARTESIAN_POINT('Origin',(-3.,6.16,0.23)); +#950=CARTESIAN_POINT('Origin',(-3.,6.16,0.23)); +#951=CARTESIAN_POINT('',(-3.115,6.16,0.23)); +#952=CARTESIAN_POINT('Origin',(-3.,6.16,0.23)); +#953=CARTESIAN_POINT('Origin',(2.6,-6.16,0.)); +#954=CARTESIAN_POINT('',(2.385,-6.16,0.)); +#955=CARTESIAN_POINT('Origin',(2.6,-6.16,0.)); +#956=CARTESIAN_POINT('',(2.385,-6.16,0.23)); +#957=CARTESIAN_POINT('',(2.385,-6.16,0.)); +#958=CARTESIAN_POINT('Origin',(2.6,-6.16,0.23)); +#959=CARTESIAN_POINT('Origin',(2.6,-6.16,0.23)); +#960=CARTESIAN_POINT('',(2.485,-6.16,0.23)); +#961=CARTESIAN_POINT('Origin',(2.6,-6.16,0.23)); +#962=CARTESIAN_POINT('Origin',(-3.,-6.16,0.)); +#963=CARTESIAN_POINT('',(-3.215,-6.16,0.)); +#964=CARTESIAN_POINT('Origin',(-3.,-6.16,0.)); +#965=CARTESIAN_POINT('',(-3.215,-6.16,0.23)); +#966=CARTESIAN_POINT('',(-3.215,-6.16,0.)); +#967=CARTESIAN_POINT('Origin',(-3.,-6.16,0.23)); +#968=CARTESIAN_POINT('Origin',(-3.,-6.16,0.23)); +#969=CARTESIAN_POINT('',(-3.115,-6.16,0.23)); +#970=CARTESIAN_POINT('Origin',(-3.,-6.16,0.23)); +#971=CARTESIAN_POINT('Origin',(2.6,6.16,0.)); +#972=CARTESIAN_POINT('',(2.385,6.16,0.)); +#973=CARTESIAN_POINT('Origin',(2.6,6.16,0.)); +#974=CARTESIAN_POINT('',(2.385,6.16,0.23)); +#975=CARTESIAN_POINT('',(2.385,6.16,0.)); +#976=CARTESIAN_POINT('Origin',(2.6,6.16,0.23)); +#977=CARTESIAN_POINT('Origin',(2.6,6.16,0.23)); +#978=CARTESIAN_POINT('',(2.485,6.16,0.23)); +#979=CARTESIAN_POINT('Origin',(2.6,6.16,0.23)); +#980=CARTESIAN_POINT('Origin',(-3.,6.16,0.)); +#981=CARTESIAN_POINT('',(-3.115,6.16,0.45)); +#982=CARTESIAN_POINT('',(-3.115,6.16,0.)); +#983=CARTESIAN_POINT('Origin',(-3.,6.16,0.45)); +#984=CARTESIAN_POINT('Origin',(2.6,-6.16,0.)); +#985=CARTESIAN_POINT('',(2.485,-6.16,0.45)); +#986=CARTESIAN_POINT('',(2.485,-6.16,0.)); +#987=CARTESIAN_POINT('Origin',(2.6,-6.16,0.45)); +#988=CARTESIAN_POINT('Origin',(-3.,-6.16,0.)); +#989=CARTESIAN_POINT('',(-3.115,-6.16,0.45)); +#990=CARTESIAN_POINT('',(-3.115,-6.16,0.)); +#991=CARTESIAN_POINT('Origin',(-3.,-6.16,0.45)); +#992=CARTESIAN_POINT('Origin',(2.6,6.16,0.)); +#993=CARTESIAN_POINT('',(2.485,6.16,0.45)); +#994=CARTESIAN_POINT('',(2.485,6.16,0.)); +#995=CARTESIAN_POINT('Origin',(2.6,6.16,0.45)); +#996=CARTESIAN_POINT('Origin',(-2.4,-3.86,0.)); +#997=CARTESIAN_POINT('',(-3.,-3.86,0.)); +#998=CARTESIAN_POINT('',(-2.4,-3.86,0.)); +#999=CARTESIAN_POINT('',(-3.,-3.86,0.)); +#1000=CARTESIAN_POINT('',(-3.,-3.86,0.45)); +#1001=CARTESIAN_POINT('',(-3.,-3.86,0.)); +#1002=CARTESIAN_POINT('',(-2.4,-3.86,0.45)); +#1003=CARTESIAN_POINT('',(-3.,-3.86,0.45)); +#1004=CARTESIAN_POINT('',(-2.4,-3.86,0.)); +#1005=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.75999999993631,0.)); +#1006=CARTESIAN_POINT('',(-2.3,-3.76,0.)); +#1007=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.75999999993631,0.)); +#1008=CARTESIAN_POINT('',(-2.3,-3.76,0.45)); +#1009=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.75999999993631,0.45)); +#1010=CARTESIAN_POINT('',(-2.3,-3.76,0.)); +#1011=CARTESIAN_POINT('Origin',(-2.3,-3.66,0.)); +#1012=CARTESIAN_POINT('',(-2.3,-3.66,0.)); +#1013=CARTESIAN_POINT('',(-2.3,-3.76,0.)); +#1014=CARTESIAN_POINT('',(-2.3,-3.66,0.45)); +#1015=CARTESIAN_POINT('',(-2.3,-3.76,0.45)); +#1016=CARTESIAN_POINT('',(-2.3,-3.66,0.)); +#1017=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.66000000006369,0.)); +#1018=CARTESIAN_POINT('',(-2.4,-3.56,0.)); +#1019=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.66000000006369,0.)); +#1020=CARTESIAN_POINT('',(-2.4,-3.56,0.45)); +#1021=CARTESIAN_POINT('Origin',(-2.40000000006369,-3.66000000006369,0.45)); +#1022=CARTESIAN_POINT('',(-2.4,-3.56,0.)); +#1023=CARTESIAN_POINT('Origin',(-7.53,-3.56,0.)); +#1024=CARTESIAN_POINT('',(-7.53,-3.56,0.)); +#1025=CARTESIAN_POINT('',(-2.4,-3.56,0.)); +#1026=CARTESIAN_POINT('',(-7.53,-3.56,0.45)); +#1027=CARTESIAN_POINT('',(-2.4,-3.56,0.45)); +#1028=CARTESIAN_POINT('',(-7.53,-3.56,0.)); +#1029=CARTESIAN_POINT('Origin',(-7.53,3.56,0.)); +#1030=CARTESIAN_POINT('',(-7.53,3.56,0.)); +#1031=CARTESIAN_POINT('',(-7.53,-3.56,0.)); +#1032=CARTESIAN_POINT('',(-7.53,3.56,0.45)); +#1033=CARTESIAN_POINT('',(-7.53,-3.56,0.45)); +#1034=CARTESIAN_POINT('',(-7.53,3.56,0.)); +#1035=CARTESIAN_POINT('Origin',(-2.4,3.56,0.)); +#1036=CARTESIAN_POINT('',(-2.4,3.56,0.)); +#1037=CARTESIAN_POINT('',(-7.53,3.56,0.)); +#1038=CARTESIAN_POINT('',(-2.4,3.56,0.45)); +#1039=CARTESIAN_POINT('',(-7.53,3.56,0.45)); +#1040=CARTESIAN_POINT('',(-2.4,3.56,0.)); +#1041=CARTESIAN_POINT('Origin',(-2.40000000006369,3.66000000006369,0.)); +#1042=CARTESIAN_POINT('',(-2.3,3.66,0.)); +#1043=CARTESIAN_POINT('Origin',(-2.40000000006369,3.66000000006369,0.)); +#1044=CARTESIAN_POINT('',(-2.3,3.66,0.45)); +#1045=CARTESIAN_POINT('Origin',(-2.40000000006369,3.66000000006369,0.45)); +#1046=CARTESIAN_POINT('',(-2.3,3.66,0.)); +#1047=CARTESIAN_POINT('Origin',(-2.3,3.76,0.)); +#1048=CARTESIAN_POINT('',(-2.3,3.76,0.)); +#1049=CARTESIAN_POINT('',(-2.3,3.66,0.)); +#1050=CARTESIAN_POINT('',(-2.3,3.76,0.45)); +#1051=CARTESIAN_POINT('',(-2.3,3.66,0.45)); +#1052=CARTESIAN_POINT('',(-2.3,3.76,0.)); +#1053=CARTESIAN_POINT('Origin',(-2.40000000006369,3.75999999993631,0.)); +#1054=CARTESIAN_POINT('',(-2.4,3.86,0.)); +#1055=CARTESIAN_POINT('Origin',(-2.40000000006369,3.75999999993631,0.)); +#1056=CARTESIAN_POINT('',(-2.4,3.86,0.45)); +#1057=CARTESIAN_POINT('Origin',(-2.40000000006369,3.75999999993631,0.45)); +#1058=CARTESIAN_POINT('',(-2.4,3.86,0.)); +#1059=CARTESIAN_POINT('Origin',(-3.,3.86,0.)); +#1060=CARTESIAN_POINT('',(-3.,3.86,0.)); +#1061=CARTESIAN_POINT('',(-2.4,3.86,0.)); +#1062=CARTESIAN_POINT('',(-3.,3.86,0.45)); +#1063=CARTESIAN_POINT('',(-2.4,3.86,0.45)); +#1064=CARTESIAN_POINT('',(-3.,3.86,0.)); +#1065=CARTESIAN_POINT('Origin',(-3.00000000015035,4.15999999984965,0.)); +#1066=CARTESIAN_POINT('',(-3.3,4.16,0.)); +#1067=CARTESIAN_POINT('Origin',(-3.00000000015035,4.15999999984965,0.)); +#1068=CARTESIAN_POINT('',(-3.3,4.16,0.45)); +#1069=CARTESIAN_POINT('Origin',(-3.00000000015035,4.15999999984965,0.45)); +#1070=CARTESIAN_POINT('',(-3.3,4.16,0.)); +#1071=CARTESIAN_POINT('Origin',(-3.3,6.16,0.)); +#1072=CARTESIAN_POINT('',(-3.3,6.16,0.)); +#1073=CARTESIAN_POINT('',(-3.3,4.16,0.)); +#1074=CARTESIAN_POINT('',(-3.3,6.16,0.45)); +#1075=CARTESIAN_POINT('',(-3.3,4.16,0.45)); +#1076=CARTESIAN_POINT('',(-3.3,6.16,0.)); +#1077=CARTESIAN_POINT('Origin',(-3.00000000015035,6.16000000015035,0.)); +#1078=CARTESIAN_POINT('',(-3.,6.46,0.)); +#1079=CARTESIAN_POINT('Origin',(-3.00000000015035,6.16000000015035,0.)); +#1080=CARTESIAN_POINT('',(-3.,6.46,0.45)); +#1081=CARTESIAN_POINT('Origin',(-3.00000000015035,6.16000000015035,0.45)); +#1082=CARTESIAN_POINT('',(-3.,6.46,0.)); +#1083=CARTESIAN_POINT('Origin',(2.6,6.46,0.)); +#1084=CARTESIAN_POINT('',(2.6,6.46,0.)); +#1085=CARTESIAN_POINT('',(-3.,6.46,0.)); +#1086=CARTESIAN_POINT('',(2.6,6.46,0.45)); +#1087=CARTESIAN_POINT('',(-3.,6.46,0.45)); +#1088=CARTESIAN_POINT('',(2.6,6.46,0.)); +#1089=CARTESIAN_POINT('Origin',(2.60000000015035,6.16000000015035,0.)); +#1090=CARTESIAN_POINT('',(2.9,6.16,0.)); +#1091=CARTESIAN_POINT('Origin',(2.60000000015035,6.16000000015035,0.)); +#1092=CARTESIAN_POINT('',(2.9,6.16,0.45)); +#1093=CARTESIAN_POINT('Origin',(2.60000000015035,6.16000000015035,0.45)); +#1094=CARTESIAN_POINT('',(2.9,6.16,0.)); +#1095=CARTESIAN_POINT('Origin',(2.9,-6.16,0.)); +#1096=CARTESIAN_POINT('',(2.9,-6.16,0.)); +#1097=CARTESIAN_POINT('',(2.9,6.16,0.)); +#1098=CARTESIAN_POINT('',(2.9,-6.16,0.45)); +#1099=CARTESIAN_POINT('',(2.9,6.16,0.45)); +#1100=CARTESIAN_POINT('',(2.9,-6.16,0.)); +#1101=CARTESIAN_POINT('Origin',(2.59999999997964,-6.15999999997964,0.)); +#1102=CARTESIAN_POINT('',(2.6,-6.46,0.)); +#1103=CARTESIAN_POINT('Origin',(2.59999999997964,-6.15999999997964,0.)); +#1104=CARTESIAN_POINT('',(2.6,-6.46,0.45)); +#1105=CARTESIAN_POINT('Origin',(2.59999999997964,-6.15999999997964,0.45)); +#1106=CARTESIAN_POINT('',(2.6,-6.46,0.)); +#1107=CARTESIAN_POINT('Origin',(-3.,-6.46,0.)); +#1108=CARTESIAN_POINT('',(-3.,-6.46,0.)); +#1109=CARTESIAN_POINT('',(2.6,-6.46,0.)); +#1110=CARTESIAN_POINT('',(-3.,-6.46,0.45)); +#1111=CARTESIAN_POINT('',(2.6,-6.46,0.45)); +#1112=CARTESIAN_POINT('',(-3.,-6.46,0.)); +#1113=CARTESIAN_POINT('Origin',(-3.00000000015035,-6.16000000015035,0.)); +#1114=CARTESIAN_POINT('',(-3.3,-6.16,0.)); +#1115=CARTESIAN_POINT('Origin',(-3.00000000015035,-6.16000000015035,0.)); +#1116=CARTESIAN_POINT('',(-3.3,-6.16,0.45)); +#1117=CARTESIAN_POINT('Origin',(-3.00000000015035,-6.16000000015035,0.45)); +#1118=CARTESIAN_POINT('',(-3.3,-6.16,0.)); +#1119=CARTESIAN_POINT('Origin',(-3.3,-4.16,0.)); +#1120=CARTESIAN_POINT('',(-3.3,-4.16,0.)); +#1121=CARTESIAN_POINT('',(-3.3,-6.16,0.)); +#1122=CARTESIAN_POINT('',(-3.3,-4.16,0.45)); +#1123=CARTESIAN_POINT('',(-3.3,-6.16,0.45)); +#1124=CARTESIAN_POINT('',(-3.3,-4.16,0.)); +#1125=CARTESIAN_POINT('Origin',(-3.00000000015035,-4.15999999984965,0.)); +#1126=CARTESIAN_POINT('Origin',(-3.00000000015035,-4.15999999984965,0.)); +#1127=CARTESIAN_POINT('Origin',(-3.00000000015035,-4.15999999984965,0.45)); +#1128=CARTESIAN_POINT('Origin',(-2.315,0.,0.45)); +#1129=CARTESIAN_POINT('Origin',(-2.315,0.,0.)); +#1130=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(0.001),#1134, +'DISTANCE_ACCURACY_VALUE', +'Maximum model space distance between geometric entities at asserted c +onnectivities'); +#1131=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(0.001),#1134, +'DISTANCE_ACCURACY_VALUE', +'Maximum model space distance between geometric entities at asserted c +onnectivities'); +#1132=( +GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#1130)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#1134,#1136,#1137)) +REPRESENTATION_CONTEXT('','3D') +); +#1133=( +GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#1131)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#1134,#1136,#1137)) +REPRESENTATION_CONTEXT('','3D') +); +#1134=( +LENGTH_UNIT() +NAMED_UNIT(*) +SI_UNIT(.CENTI.,.METRE.) +); +#1135=( +LENGTH_UNIT() +NAMED_UNIT(*) +SI_UNIT($,.METRE.) +); +#1136=( +NAMED_UNIT(*) +PLANE_ANGLE_UNIT() +SI_UNIT($,.RADIAN.) +); +#1137=( +NAMED_UNIT(*) +SI_UNIT($,.STERADIAN.) +SOLID_ANGLE_UNIT() +); +#1138=SHAPE_DEFINITION_REPRESENTATION(#1139,#1140); +#1139=PRODUCT_DEFINITION_SHAPE('',$,#1142); +#1140=SHAPE_REPRESENTATION('',(#670),#1132); +#1141=PRODUCT_DEFINITION_CONTEXT('part definition',#1146,'design'); +#1142=PRODUCT_DEFINITION('2026-09-25-20-10-25-456','(Unsaved)',#1143,#1141); +#1143=PRODUCT_DEFINITION_FORMATION('',$,#1148); +#1144=PRODUCT_RELATED_PRODUCT_CATEGORY('(Unsaved)','(Unsaved)',(#1148)); +#1145=APPLICATION_PROTOCOL_DEFINITION('international standard', +'automotive_design',2009,#1146); +#1146=APPLICATION_CONTEXT( +'Core Data for Automotive Mechanical Design Process'); +#1147=PRODUCT_CONTEXT('part definition',#1146,'mechanical'); +#1148=PRODUCT('2026-09-25-20-10-25-456','(Unsaved)',$,(#1147)); +#1149=PRESENTATION_STYLE_ASSIGNMENT((#1150)); +#1150=SURFACE_STYLE_USAGE(.BOTH.,#1151); +#1151=SURFACE_SIDE_STYLE('',(#1152)); +#1152=SURFACE_STYLE_FILL_AREA(#1153); +#1153=FILL_AREA_STYLE('Steel - Satin',(#1154)); +#1154=FILL_AREA_STYLE_COLOUR('Steel - Satin',#1155); +#1155=COLOUR_RGB('Steel - Satin',0.627450980392157,0.627450980392157,0.627450980392157); +ENDSEC; +END-ISO-10303-21; diff --git a/3d_models/parts/hd1370a/bottom-cover/README.md b/3d_models/parts/hd1370a/bottom-cover/README.md new file mode 100644 index 0000000..f978b34 --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/README.md @@ -0,0 +1,58 @@ +# Optional HD1370A bottom cover + +A removable T-shaped cover for the underside of the HD1370A desk and chair, with four recessed M2 head seats and a flat exterior face. **Prototype: perimeter and head-seat geometry checked in CAD; physical fit and screw retention are not yet verified.** This fixed outline does not fit SG90 or FS0307. + +![Cover aligned with the desk and chair](fit-isometric.png) + +## Files + +- [Printable 3MF](../3mf/BottomCover.3mf) and [STL](../stl/BottomCover.stl): one part, millimeters, 100% scale, recesses facing up. No printer or filament profile is embedded. +- [Editable Fusion cover](../../../cad/bottom-cover/BottomCover_HD1370A.f3d): fixed source-derived perimeter; editable thickness and screw/head clearances. +- [STEP](../step/BottomCover.step): installed orientation, floor at Z=0 and mating face at Z=4.5 mm. +- [Aligned Fusion inspection assembly](../../../cad/bottom-cover/BottomCover_FitCheck_HD1370A.f3d): original desk, chair, desktop, pad and four reference screw envelopes. **Do not print this assembly or its screw envelopes.** +- [Master Fusion assembly](../../../cad/TinyEngineer.f3d): includes `OPTIONAL_BOTTOM_COVER_HD1370A`, hidden by default and outside `PRINT_LAYOUT`. Apply the HD1370A servo preset before showing it. It is a fixed reference body; edit the independent cover and run the integration script to replace it. The normal exporter therefore cannot include this HD1370A-only part in another servo family's export. + +## Dimensions + +| Feature | mm | +| --- | --- | +| Overall width × front-to-back depth × thickness | 129.2 × 104.3 × 4.5 | +| Four shaft clearance holes | Ø2.3 | +| Four underside head recesses | Ø4.3 × 2.3 deep | +| Plastic above each head seat | 2.2 | +| Hole-center spacing | 123.2 × 56 | +| Outer border offset | 0 | + +The outline copies 21 line/arc segments from the actual desk underside: R3 desk corners and shoulder transitions, R1 notch ends, and square rear corners. A straight rear edge coincides with the desk/chair rear plane and spans the two existing 0.3 mm assembly seams. [All-corner comparison](perimeter-corner-check.png). + +## Fastening limitation + +The modeled screw envelope is M2×6 with a 4 mm-diameter, 2 mm-high head. The head rests against a shoulder and stays 0.3 mm above the floor. The shaft passes through 2.2 mm of plastic and extends 3.8 mm into the desk channel. That is insertion length, **not verified thread engagement**. Actual pan/button heads must fit the modeled envelope. + +The existing desk channels are smooth Ø2.1 mm in CAD. An M2 machine screw without a nut must grip the actual printed hole for this attachment to work. If the screw slides or spins freely, this cover does not provide a secure fastening solution. No nut pockets, inserts or modeled threads are included. Follow the repository's [screw sizing test](../../../README.md#print-first) before relying on the attachment. Do not enlarge the desk channels to the cover's clearance diameter. + +![Section through the print-file screw seat](screw-seat-section.png) + +## Printing and fitting + +Print the supplied 3MF/STL with the large recesses facing up and the mating face on the bed. This avoids bridging the head pockets. PLA or PETG, 0.2 mm layers and at least four walls are starting settings; use a calibrated material profile. The footprint fits a 180 × 180 mm bed. No supports are required by the geometry. + +Dry-fit before adding screws. Remove first-layer flare if it prevents flush seating. Check the wire bundle stays above the mating plane and the existing USB opening remains accessible. Tighten only until seated, and verify that neither a screw head nor a warped corner touches the desk first. Retain removable access to electronics. + +## Verification + +- Independent Fusion STEP and CadQuery solids: zero symmetric-difference volume. +- Source underside versus cover perimeter: zero excess/missing area; sampled edge deviation below 0.000001 mm. +- Four hole centers align with the existing desk channels; no solid intersections with desk, chair, desktop or pad. +- Four head seats stop the reference screw heads; pushing each head 0.1 mm into its shoulder produces an intersection. The bearing overlap is 0.85 mm radially. +- Native Fusion archive reopens with one solid, three healthy modeling features and six timeline entries. +- Printable 3MF: one watertight mesh, four through-holes, correct dimensions and upward-facing recesses. +- Updated master: original user parameters and original geometry checked, optional reference hidden, and HD1370A interference checked separately. + +These checks do not establish screw grip, printing tolerances, wiring clearance, thermal behavior or full robot motion. **No completed physical print or assembled fit is claimed.** + +Evidence: [geometry](verification.json), [perimeter](perimeter-verification.json), [Fusion](fusion-verification.json), [assembly](fusion-final-checks.json), [print mesh](print-verification.json), [head seats](screw-seat-check.json), [master integration](master-integration-verification.json). + +## Source and license + +[Rebuild instructions and scripts](../../../cad/bottom-cover/README.md). Derived from Tiny Engineer by Krzysztof Jamroz; cover addition by Hanson Wen, 2026. CAD and exports are CERN-OHL-S-2.0; see [LICENSE](../../../LICENSE) and [NOTICE](../../../NOTICE). The modified source location is recorded in NOTICE; use the corresponding revision when distributing this modification. diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-front.png b/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-front.png new file mode 100644 index 0000000..5f01e97 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-front.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-rear.png b/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-rear.png new file mode 100644 index 0000000..d61f6b2 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-desk-left-rear.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-front.png b/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-front.png new file mode 100644 index 0000000..b301ddc Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-front.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-rear.png b/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-rear.png new file mode 100644 index 0000000..acba202 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-desk-right-rear.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-rear-left.png b/3d_models/parts/hd1370a/bottom-cover/corner-rear-left.png new file mode 100644 index 0000000..08d73f6 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-rear-left.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-rear-right.png b/3d_models/parts/hd1370a/bottom-cover/corner-rear-right.png new file mode 100644 index 0000000..9f524af Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-rear-right.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-left.png b/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-left.png new file mode 100644 index 0000000..61b9c72 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-left.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-right.png b/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-right.png new file mode 100644 index 0000000..cd60eff Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/corner-shoulder-right.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/cover-underside.png b/3d_models/parts/hd1370a/bottom-cover/cover-underside.png new file mode 100644 index 0000000..f452179 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/cover-underside.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-bottom.png b/3d_models/parts/hd1370a/bottom-cover/fit-bottom.png new file mode 100644 index 0000000..6ed6cf8 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-bottom.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-front.png b/3d_models/parts/hd1370a/bottom-cover/fit-front.png new file mode 100644 index 0000000..5f82935 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-front.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-isometric.png b/3d_models/parts/hd1370a/bottom-cover/fit-isometric.png new file mode 100644 index 0000000..e8a366c Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-isometric.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-side.png b/3d_models/parts/hd1370a/bottom-cover/fit-side.png new file mode 100644 index 0000000..b733e55 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-side.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-underside.png b/3d_models/parts/hd1370a/bottom-cover/fit-underside.png new file mode 100644 index 0000000..fb0d453 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-underside.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fit-with-recessed-screws.png b/3d_models/parts/hd1370a/bottom-cover/fit-with-recessed-screws.png new file mode 100644 index 0000000..a226254 Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/fit-with-recessed-screws.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/fusion-final-checks.json b/3d_models/parts/hd1370a/bottom-cover/fusion-final-checks.json new file mode 100644 index 0000000..b8e303b --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/fusion-final-checks.json @@ -0,0 +1,38 @@ +{ + "revision": 2, + "full_original_assembly_interference": { + "Chair": 0, + "Desk": 0, + "DeskPad": 0, + "DeskTop": 0 + }, + "screw_envelopes": [ + { + "head_floor_gap_mm": 0.3, + "cover_interference": 0, + "desk_interference": 0 + }, + { + "head_floor_gap_mm": 0.3, + "cover_interference": 0, + "desk_interference": 0 + }, + { + "head_floor_gap_mm": 0.3, + "cover_interference": 0, + "desk_interference": 0 + }, + { + "head_floor_gap_mm": 0.3, + "cover_interference": 0, + "desk_interference": 0 + } + ], + "native_f3d_reopened": { + "body_count": 1, + "volume_mm3": 49111.270220730024, + "timeline_count": 6 + }, + "all_geometric_checks_pass": true, + "thread_retention_verified": false +} diff --git a/3d_models/parts/hd1370a/bottom-cover/fusion-verification.json b/3d_models/parts/hd1370a/bottom-cover/fusion-verification.json new file mode 100644 index 0000000..4aa1eab --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/fusion-verification.json @@ -0,0 +1,58 @@ +{ + "revision": 2, + "outline_source": "underside-profile.json; actual underside edges with zero offset", + "body_count": 1, + "is_solid": true, + "volume_mm3": 49111.270220730024, + "timeline_features": 6, + "feature_health": [ + { + "name": "Plate - exact flush rim and flat floor", + "state": 0, + "message": "" + }, + { + "name": "M2 through holes (1)", + "state": 0, + "message": "" + }, + { + "name": "Recessed M2 heads on floor side (1)", + "state": 0, + "message": "" + } + ], + "fit_occurrences": [ + { + "path": "BottomCover:1", + "name": "BottomCover" + }, + { + "path": "Desk:1", + "name": "Desk" + }, + { + "path": "Chair:1", + "name": "Chair" + }, + { + "path": "DeskTop:1", + "name": "DeskTop" + }, + { + "path": "DeskPad:1", + "name": "DeskPad" + } + ], + "interference": { + "Desk": 0, + "Chair": 0, + "DeskTop": 0, + "DeskPad": 0 + }, + "source_global_offset_mm": [ + 43.5, + -13.9259877217, + -15.4740122783 + ] +} diff --git a/3d_models/parts/hd1370a/bottom-cover/master-integration-verification.json b/3d_models/parts/hd1370a/bottom-cover/master-integration-verification.json new file mode 100644 index 0000000..0f8a4f4 --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/master-integration-verification.json @@ -0,0 +1,51 @@ +{ + "scope": "Optional HD1370A reference in current upstream master", + "thread_retention_verified": false, + "hd1370a_interference": { + "Desk": 0, + "Chair": 0, + "DeskTop": 0, + "DeskPad": 0 + }, + "original_geometry_identical_before_save": true, + "original_user_parameters_preserved": true, + "default_servo_expression": "'sg90'", + "optional_component_hidden": true, + "original_occurrence_count": 87, + "outside_print_layout": true, + "max_original_geometry_numeric_change_after_reopen": 0.0, + "master_archive_reopened": true, + "cover_volume_mm3": 49111.27022072877, + "native_master_mate_comparison": { + "Desk": { + "valid_solids": true, + "volume_difference_mm3": 9.531504474580288e-10, + "face_counts": [ + 228, + 228 + ], + "edge_counts": [ + 655, + 655 + ], + "native_to_fixture_max_sampled_edge_distance_mm": 2.2196424601986253e-10, + "fixture_to_native_max_sampled_edge_distance_mm": 2.4990814052563653e-10, + "samples_per_edge": 11 + }, + "Chair": { + "valid_solids": true, + "volume_difference_mm3": 8.440110832452774e-10, + "face_counts": [ + 78, + 78 + ], + "edge_counts": [ + 215, + 215 + ], + "native_to_fixture_max_sampled_edge_distance_mm": 4.4437176391450477e-11, + "fixture_to_native_max_sampled_edge_distance_mm": 5.026630994684662e-11, + "samples_per_edge": 11 + } + } +} diff --git a/3d_models/parts/hd1370a/bottom-cover/perimeter-corner-check.png b/3d_models/parts/hd1370a/bottom-cover/perimeter-corner-check.png new file mode 100644 index 0000000..e68db0e Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/perimeter-corner-check.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/perimeter-verification.json b/3d_models/parts/hd1370a/bottom-cover/perimeter-verification.json new file mode 100644 index 0000000..0e5bda6 --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/perimeter-verification.json @@ -0,0 +1,7 @@ +{ + "revision": 2, + "fusion_vs_cadquery_symmetric_difference_mm3": 0.0, + "fusion_perimeter_excess_area_mm2": 0.0, + "fusion_perimeter_missing_area_mm2": 0.0, + "fusion_max_sampled_boundary_deviation_mm": 6.642632261806385e-10 +} diff --git a/3d_models/parts/hd1370a/bottom-cover/print-verification.json b/3d_models/parts/hd1370a/bottom-cover/print-verification.json new file mode 100644 index 0000000..7ea1e4a --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/print-verification.json @@ -0,0 +1,46 @@ +{ + "revision": 2, + "mesh_count": 1, + "bounds_mm": [ + [ + -75.3, + -64.6, + 0.0 + ], + [ + 29.0, + 64.6, + 4.5 + ] + ], + "extents_mm": [ + 104.3, + 129.2, + 4.5 + ], + "watertight": true, + "winding_consistent": true, + "euler_number": -6, + "volume_mm3": 49111.26985144659, + "units": "mm", + "sections": [ + { + "height_from_print_bed_mm": 0.5, + "hole_equivalent_diameters_mm": [ + 2.299941846965864, + 2.2999418469658646, + 2.299941846965865, + 2.299941846965865 + ] + }, + { + "height_from_print_bed_mm": 3.5, + "hole_equivalent_diameters_mm": [ + 4.299890674435669, + 4.2998906744356695, + 4.299890708703264, + 4.29989070870327 + ] + } + ] +} diff --git a/3d_models/parts/hd1370a/bottom-cover/screw-seat-check.json b/3d_models/parts/hd1370a/bottom-cover/screw-seat-check.json new file mode 100644 index 0000000..2763d32 --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/screw-seat-check.json @@ -0,0 +1,43 @@ +{ + "all_four_head_shoulders_present": true, + "checks": [ + { + "centre_mm": [ + -30, + -61.6 + ], + "seated_head_collision_mm3": 0.0, + "head_pushed_up_0p1mm_collision_mm3": 0.8411614329986641 + }, + { + "centre_mm": [ + 26, + -61.6 + ], + "seated_head_collision_mm3": 0.0, + "head_pushed_up_0p1mm_collision_mm3": 0.8411614329986641 + }, + { + "centre_mm": [ + -30, + 61.6 + ], + "seated_head_collision_mm3": 0.0, + "head_pushed_up_0p1mm_collision_mm3": 0.8411614329986641 + }, + { + "centre_mm": [ + 26, + 61.6 + ], + "seated_head_collision_mm3": 0.0, + "head_pushed_up_0p1mm_collision_mm3": 0.8411614329986641 + } + ], + "through_hole_mm": 2.3, + "head_recess_mm": 4.3, + "recess_depth_mm": 2.3, + "plastic_above_head_seat_mm": 2.2, + "reference_head_overlap_per_side_mm": 0.85, + "scope": "Checks head retention against the cover only. Desk pilot thread engagement depends on actual screw and printed hole size; zero collision does not establish grip." +} diff --git a/3d_models/parts/hd1370a/bottom-cover/screw-seat-section.png b/3d_models/parts/hd1370a/bottom-cover/screw-seat-section.png new file mode 100644 index 0000000..c78222b Binary files /dev/null and b/3d_models/parts/hd1370a/bottom-cover/screw-seat-section.png differ diff --git a/3d_models/parts/hd1370a/bottom-cover/verification.json b/3d_models/parts/hd1370a/bottom-cover/verification.json new file mode 100644 index 0000000..3d426cb --- /dev/null +++ b/3d_models/parts/hd1370a/bottom-cover/verification.json @@ -0,0 +1,460 @@ +{ + "parameters_mm": { + "thickness": 4.5, + "clearance": 0.3, + "hole_diameter": 2.3, + "head_diameter": 4.3, + "head_depth": 2.3 + }, + "outline_segments_mm": [ + { + "type": "LINE", + "start_mm": [ + -75.3, + 35.6 + ], + "end_mm": [ + -24.0, + 35.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -24.0, + 35.6 + ], + "end_mm": [ + -23.0, + 36.6 + ], + "mid_mm": [ + -23.292893219, + 35.892893219 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -23.0, + 36.6 + ], + "end_mm": [ + -23.0, + 37.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -23.0, + 37.6 + ], + "end_mm": [ + -24.0, + 38.6 + ], + "mid_mm": [ + -23.292893219, + 38.307106781 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -24.0, + 38.6 + ], + "end_mm": [ + -30.0, + 38.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -30.0, + 38.6 + ], + "end_mm": [ + -33.0, + 41.6 + ], + "mid_mm": [ + -32.121320344, + 39.478679656 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -33.0, + 41.6 + ], + "end_mm": [ + -33.0, + 61.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -33.0, + 61.6 + ], + "end_mm": [ + -30.0, + 64.6 + ], + "mid_mm": [ + -32.121320344, + 63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -30.0, + 64.6 + ], + "end_mm": [ + 26.0, + 64.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + 26.0, + 64.6 + ], + "end_mm": [ + 29.0, + 61.6 + ], + "mid_mm": [ + 28.121320344, + 63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + 29.0, + 61.6 + ], + "end_mm": [ + 29.0, + -61.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + 29.0, + -61.6 + ], + "end_mm": [ + 26.0, + -64.6 + ], + "mid_mm": [ + 28.121320343, + -63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + 26.0, + -64.6 + ], + "end_mm": [ + -30.0, + -64.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -30.0, + -64.6 + ], + "end_mm": [ + -33.0, + -61.6 + ], + "mid_mm": [ + -32.121320344, + -63.721320344 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -33.0, + -61.6 + ], + "end_mm": [ + -33.0, + -41.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -33.0, + -41.6 + ], + "end_mm": [ + -30.0, + -38.6 + ], + "mid_mm": [ + -32.121320344, + -39.478679656 + ], + "radius_mm": 3.0 + }, + { + "type": "LINE", + "start_mm": [ + -30.0, + -38.6 + ], + "end_mm": [ + -24.0, + -38.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -24.0, + -38.6 + ], + "end_mm": [ + -23.0, + -37.6 + ], + "mid_mm": [ + -23.292893219, + -38.307106781 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -23.0, + -37.6 + ], + "end_mm": [ + -23.0, + -36.6 + ] + }, + { + "type": "CIRCLE", + "start_mm": [ + -23.0, + -36.6 + ], + "end_mm": [ + -24.0, + -35.6 + ], + "mid_mm": [ + -23.292893219, + -35.892893219 + ], + "radius_mm": 1.0 + }, + { + "type": "LINE", + "start_mm": [ + -24.0, + -35.6 + ], + "end_mm": [ + -75.3, + -35.6 + ] + }, + { + "type": "LINE", + "start_mm": [ + -75.3, + -35.6 + ], + "end_mm": [ + -75.3, + 35.6 + ] + } + ], + "revision": 2, + "hole_centres_mm": [ + [ + -30, + -61.6 + ], + [ + 26, + -61.6 + ], + [ + -30, + 61.6 + ], + [ + 26, + 61.6 + ] + ], + "scope": "HD1370A only; CAD verified, physical print not yet fit-tested", + "assembly_transforms": { + "Desk": "rotate X 180 deg; translate (0,0,38.5) mm", + "Chair": "translate (-59.3,0,4.5) mm", + "DeskTop": "translate (0,0,40.0) mm", + "DeskPad": "translate (-2,0.0000082699,38.5) mm" + }, + "valid_solid": true, + "solid_count": 1, + "mesh_watertight": true, + "mesh_winding_consistent": true, + "mesh_euler_number": -6, + "volume_mm3": 49111.27022073003, + "bounds_mm": [ + [ + -75.3, + -64.6, + -7.993605777301127e-15 + ], + [ + 29.0, + 64.6, + 4.500000000000008 + ] + ], + "part_interference_mm3": { + "Desk": 0.0, + "Chair": 0.0, + "DeskTop": 0.0, + "DeskPad": 0.0 + }, + "head_checks": [ + { + "centre_mm": [ + -30, + -61.6 + ], + "head_to_floor_clearance_mm": 0.3, + "radial_head_clearance_mm": 0.15, + "radial_shank_clearance_mm": 0.15, + "remaining_plate_bearing_mm": 2.2, + "M2x6_insertion_into_desk_mm": 3.8, + "head_plate_interference_mm3": 0.0, + "shank_plate_interference_mm3": 0.0, + "shank_desk_interference_mm3": 0.0 + }, + { + "centre_mm": [ + 26, + -61.6 + ], + "head_to_floor_clearance_mm": 0.3, + "radial_head_clearance_mm": 0.15, + "radial_shank_clearance_mm": 0.15, + "remaining_plate_bearing_mm": 2.2, + "M2x6_insertion_into_desk_mm": 3.8, + "head_plate_interference_mm3": 0.0, + "shank_plate_interference_mm3": 0.0, + "shank_desk_interference_mm3": 0.0 + }, + { + "centre_mm": [ + -30, + 61.6 + ], + "head_to_floor_clearance_mm": 0.3, + "radial_head_clearance_mm": 0.15, + "radial_shank_clearance_mm": 0.15, + "remaining_plate_bearing_mm": 2.2, + "M2x6_insertion_into_desk_mm": 3.8, + "head_plate_interference_mm3": 0.0, + "shank_plate_interference_mm3": 0.0, + "shank_desk_interference_mm3": 0.0 + }, + { + "centre_mm": [ + 26, + 61.6 + ], + "head_to_floor_clearance_mm": 0.3, + "radial_head_clearance_mm": 0.15, + "radial_shank_clearance_mm": 0.15, + "remaining_plate_bearing_mm": 2.2, + "M2x6_insertion_into_desk_mm": 3.8, + "head_plate_interference_mm3": 0.0, + "shank_plate_interference_mm3": 0.0, + "shank_desk_interference_mm3": 0.0 + } + ], + "perimeter_fit": { + "perimeter_offset_mm": 0, + "excess_footprint_area_mm2": 0.0, + "missing_footprint_area_mm2": 0.0, + "max_sampled_source_edge_deviation_mm": 6.642349625640078e-10, + "copied_desk_edge_count": 21, + "radii_mm": [ + 1.0, + 1.0, + 3.0, + 3.0, + 3.0, + 3.0, + 3.0, + 3.0, + 1.0, + 1.0 + ], + "square_rear_corners_mm": [ + [ + -75.3, + -35.6 + ], + [ + -75.3, + 35.6 + ] + ], + "rear_seam_bridges_mm": [ + 0.3, + 0.3 + ], + "note": "Straight rear closure coincides with chair and desk rear planes and bridges only their two existing 0.3 mm assembly seams." + }, + "step_roundtrip_valid": true, + "step_roundtrip_volume_error_mm3": 6.184563972055912e-10, + "3mf_mesh_count": 1, + "3mf_bounds_mm": [ + [ + -75.3, + -64.6, + -7.993605777301127e-15 + ], + [ + 29.0, + 64.6, + 4.500000000000008 + ] + ] +} diff --git a/3d_models/parts/hd1370a/step/BottomCover.step b/3d_models/parts/hd1370a/step/BottomCover.step new file mode 100644 index 0000000..b230b15 --- /dev/null +++ b/3d_models/parts/hd1370a/step/BottomCover.step @@ -0,0 +1,3034 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('Open CASCADE Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2026-09-25T20:33:02',('Author'),( + 'Open CASCADE'),'Open CASCADE STEP processor 7.9','Open CASCADE 7.9' + ,'Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('Open CASCADE STEP translator 7.9 1', + 'Open CASCADE STEP translator 7.9 1','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#15),#2545); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = MANIFOLD_SOLID_BREP('',#16); +#16 = CLOSED_SHELL('',(#17,#137,#213,#299,#986,#1588,#1615,#1642,#1669, + #1696,#1723,#1750,#1777,#1804,#1831,#1858,#1885,#1912,#1939,#1966, + #1993,#2020,#2047,#2074,#2081,#2136,#2191,#2246,#2301,#2355,#2409, + #2463,#2517,#2524,#2531,#2538)); +#17 = ADVANCED_FACE('',(#18),#32,.T.); +#18 = FACE_BOUND('',#19,.T.); +#19 = EDGE_LOOP('',(#20,#55,#83,#111)); +#20 = ORIENTED_EDGE('',*,*,#21,.T.); +#21 = EDGE_CURVE('',#22,#24,#26,.T.); +#22 = VERTEX_POINT('',#23); +#23 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#24 = VERTEX_POINT('',#25); +#25 = CARTESIAN_POINT('',(-75.3,35.6,4.5)); +#26 = SURFACE_CURVE('',#27,(#31,#43),.PCURVE_S1.); +#27 = LINE('',#28,#29); +#28 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#29 = VECTOR('',#30,1.); +#30 = DIRECTION('',(0.,0.,1.)); +#31 = PCURVE('',#32,#37); +#32 = PLANE('',#33); +#33 = AXIS2_PLACEMENT_3D('',#34,#35,#36); +#34 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#35 = DIRECTION('',(0.,1.,0.)); +#36 = DIRECTION('',(1.,0.,0.)); +#37 = DEFINITIONAL_REPRESENTATION('',(#38),#42); +#38 = LINE('',#39,#40); +#39 = CARTESIAN_POINT('',(0.,0.)); +#40 = VECTOR('',#41,1.); +#41 = DIRECTION('',(0.,-1.)); +#42 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#43 = PCURVE('',#44,#49); +#44 = PLANE('',#45); +#45 = AXIS2_PLACEMENT_3D('',#46,#47,#48); +#46 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#47 = DIRECTION('',(-1.,0.,0.)); +#48 = DIRECTION('',(0.,1.,0.)); +#49 = DEFINITIONAL_REPRESENTATION('',(#50),#54); +#50 = LINE('',#51,#52); +#51 = CARTESIAN_POINT('',(71.2,0.)); +#52 = VECTOR('',#53,1.); +#53 = DIRECTION('',(0.,-1.)); +#54 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#55 = ORIENTED_EDGE('',*,*,#56,.T.); +#56 = EDGE_CURVE('',#24,#57,#59,.T.); +#57 = VERTEX_POINT('',#58); +#58 = CARTESIAN_POINT('',(-24.,35.6,4.5)); +#59 = SURFACE_CURVE('',#60,(#64,#71),.PCURVE_S1.); +#60 = LINE('',#61,#62); +#61 = CARTESIAN_POINT('',(-75.3,35.6,4.5)); +#62 = VECTOR('',#63,1.); +#63 = DIRECTION('',(1.,0.,0.)); +#64 = PCURVE('',#32,#65); +#65 = DEFINITIONAL_REPRESENTATION('',(#66),#70); +#66 = LINE('',#67,#68); +#67 = CARTESIAN_POINT('',(0.,-4.5)); +#68 = VECTOR('',#69,1.); +#69 = DIRECTION('',(1.,0.)); +#70 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#71 = PCURVE('',#72,#77); +#72 = PLANE('',#73); +#73 = AXIS2_PLACEMENT_3D('',#74,#75,#76); +#74 = CARTESIAN_POINT('',(-18.65791794382,8.530512611009E-11,4.5)); +#75 = DIRECTION('',(-0.,-0.,-1.)); +#76 = DIRECTION('',(-1.,0.,0.)); +#77 = DEFINITIONAL_REPRESENTATION('',(#78),#82); +#78 = LINE('',#79,#80); +#79 = CARTESIAN_POINT('',(56.642082056175,35.599999999915)); +#80 = VECTOR('',#81,1.); +#81 = DIRECTION('',(-1.,0.)); +#82 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#83 = ORIENTED_EDGE('',*,*,#84,.F.); +#84 = EDGE_CURVE('',#85,#57,#87,.T.); +#85 = VERTEX_POINT('',#86); +#86 = CARTESIAN_POINT('',(-24.,35.6,0.)); +#87 = SURFACE_CURVE('',#88,(#92,#99),.PCURVE_S1.); +#88 = LINE('',#89,#90); +#89 = CARTESIAN_POINT('',(-24.,35.6,0.)); +#90 = VECTOR('',#91,1.); +#91 = DIRECTION('',(0.,0.,1.)); +#92 = PCURVE('',#32,#93); +#93 = DEFINITIONAL_REPRESENTATION('',(#94),#98); +#94 = LINE('',#95,#96); +#95 = CARTESIAN_POINT('',(51.3,0.)); +#96 = VECTOR('',#97,1.); +#97 = DIRECTION('',(0.,-1.)); +#98 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#99 = PCURVE('',#100,#105); +#100 = CYLINDRICAL_SURFACE('',#101,1.000000000637); +#101 = AXIS2_PLACEMENT_3D('',#102,#103,#104); +#102 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,0.)); +#103 = DIRECTION('',(-0.,-0.,-1.)); +#104 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#105 = DEFINITIONAL_REPRESENTATION('',(#106),#110); +#106 = LINE('',#107,#108); +#107 = CARTESIAN_POINT('',(-0.,0.)); +#108 = VECTOR('',#109,1.); +#109 = DIRECTION('',(-0.,-1.)); +#110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#111 = ORIENTED_EDGE('',*,*,#112,.F.); +#112 = EDGE_CURVE('',#22,#85,#113,.T.); +#113 = SURFACE_CURVE('',#114,(#118,#125),.PCURVE_S1.); +#114 = LINE('',#115,#116); +#115 = CARTESIAN_POINT('',(-75.3,35.6,0.)); +#116 = VECTOR('',#117,1.); +#117 = DIRECTION('',(1.,0.,0.)); +#118 = PCURVE('',#32,#119); +#119 = DEFINITIONAL_REPRESENTATION('',(#120),#124); +#120 = LINE('',#121,#122); +#121 = CARTESIAN_POINT('',(0.,0.)); +#122 = VECTOR('',#123,1.); +#123 = DIRECTION('',(1.,0.)); +#124 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#125 = PCURVE('',#126,#131); +#126 = PLANE('',#127); +#127 = AXIS2_PLACEMENT_3D('',#128,#129,#130); +#128 = CARTESIAN_POINT('',(-18.65791794382,8.530512611009E-11,0.)); +#129 = DIRECTION('',(-0.,-0.,-1.)); +#130 = DIRECTION('',(-1.,0.,0.)); +#131 = DEFINITIONAL_REPRESENTATION('',(#132),#136); +#132 = LINE('',#133,#134); +#133 = CARTESIAN_POINT('',(56.642082056175,35.599999999915)); +#134 = VECTOR('',#135,1.); +#135 = DIRECTION('',(-1.,0.)); +#136 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#137 = ADVANCED_FACE('',(#138),#44,.T.); +#138 = FACE_BOUND('',#139,.T.); +#139 = EDGE_LOOP('',(#140,#170,#191,#192)); +#140 = ORIENTED_EDGE('',*,*,#141,.T.); +#141 = EDGE_CURVE('',#142,#144,#146,.T.); +#142 = VERTEX_POINT('',#143); +#143 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#144 = VERTEX_POINT('',#145); +#145 = CARTESIAN_POINT('',(-75.3,-35.6,4.5)); +#146 = SURFACE_CURVE('',#147,(#151,#158),.PCURVE_S1.); +#147 = LINE('',#148,#149); +#148 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#149 = VECTOR('',#150,1.); +#150 = DIRECTION('',(0.,0.,1.)); +#151 = PCURVE('',#44,#152); +#152 = DEFINITIONAL_REPRESENTATION('',(#153),#157); +#153 = LINE('',#154,#155); +#154 = CARTESIAN_POINT('',(0.,0.)); +#155 = VECTOR('',#156,1.); +#156 = DIRECTION('',(0.,-1.)); +#157 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#158 = PCURVE('',#159,#164); +#159 = PLANE('',#160); +#160 = AXIS2_PLACEMENT_3D('',#161,#162,#163); +#161 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#162 = DIRECTION('',(0.,-1.,0.)); +#163 = DIRECTION('',(-1.,0.,0.)); +#164 = DEFINITIONAL_REPRESENTATION('',(#165),#169); +#165 = LINE('',#166,#167); +#166 = CARTESIAN_POINT('',(51.3,0.)); +#167 = VECTOR('',#168,1.); +#168 = DIRECTION('',(0.,-1.)); +#169 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#170 = ORIENTED_EDGE('',*,*,#171,.T.); +#171 = EDGE_CURVE('',#144,#24,#172,.T.); +#172 = SURFACE_CURVE('',#173,(#177,#184),.PCURVE_S1.); +#173 = LINE('',#174,#175); +#174 = CARTESIAN_POINT('',(-75.3,-35.6,4.5)); +#175 = VECTOR('',#176,1.); +#176 = DIRECTION('',(0.,1.,0.)); +#177 = PCURVE('',#44,#178); +#178 = DEFINITIONAL_REPRESENTATION('',(#179),#183); +#179 = LINE('',#180,#181); +#180 = CARTESIAN_POINT('',(0.,-4.5)); +#181 = VECTOR('',#182,1.); +#182 = DIRECTION('',(1.,0.)); +#183 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#184 = PCURVE('',#72,#185); +#185 = DEFINITIONAL_REPRESENTATION('',(#186),#190); +#186 = LINE('',#187,#188); +#187 = CARTESIAN_POINT('',(56.642082056175,-35.60000000008)); +#188 = VECTOR('',#189,1.); +#189 = DIRECTION('',(0.,1.)); +#190 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#191 = ORIENTED_EDGE('',*,*,#21,.F.); +#192 = ORIENTED_EDGE('',*,*,#193,.F.); +#193 = EDGE_CURVE('',#142,#22,#194,.T.); +#194 = SURFACE_CURVE('',#195,(#199,#206),.PCURVE_S1.); +#195 = LINE('',#196,#197); +#196 = CARTESIAN_POINT('',(-75.3,-35.6,0.)); +#197 = VECTOR('',#198,1.); +#198 = DIRECTION('',(0.,1.,0.)); +#199 = PCURVE('',#44,#200); +#200 = DEFINITIONAL_REPRESENTATION('',(#201),#205); +#201 = LINE('',#202,#203); +#202 = CARTESIAN_POINT('',(0.,0.)); +#203 = VECTOR('',#204,1.); +#204 = DIRECTION('',(1.,0.)); +#205 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#206 = PCURVE('',#126,#207); +#207 = DEFINITIONAL_REPRESENTATION('',(#208),#212); +#208 = LINE('',#209,#210); +#209 = CARTESIAN_POINT('',(56.642082056175,-35.60000000008)); +#210 = VECTOR('',#211,1.); +#211 = DIRECTION('',(0.,1.)); +#212 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#213 = ADVANCED_FACE('',(#214),#100,.F.); +#214 = FACE_BOUND('',#215,.T.); +#215 = EDGE_LOOP('',(#216,#217,#245,#273)); +#216 = ORIENTED_EDGE('',*,*,#84,.T.); +#217 = ORIENTED_EDGE('',*,*,#218,.T.); +#218 = EDGE_CURVE('',#57,#219,#221,.T.); +#219 = VERTEX_POINT('',#220); +#220 = CARTESIAN_POINT('',(-23.,36.6,4.5)); +#221 = SURFACE_CURVE('',#222,(#227,#234),.PCURVE_S1.); +#222 = CIRCLE('',#223,1.000000000637); +#223 = AXIS2_PLACEMENT_3D('',#224,#225,#226); +#224 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,4.5)); +#225 = DIRECTION('',(0.,0.,1.)); +#226 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#227 = PCURVE('',#100,#228); +#228 = DEFINITIONAL_REPRESENTATION('',(#229),#233); +#229 = LINE('',#230,#231); +#230 = CARTESIAN_POINT('',(-0.,-4.5)); +#231 = VECTOR('',#232,1.); +#232 = DIRECTION('',(-1.,0.)); +#233 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#234 = PCURVE('',#72,#235); +#235 = DEFINITIONAL_REPRESENTATION('',(#236),#244); +#236 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#237,#238,#239,#240,#241,#242 +,#243),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#237 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#238 = CARTESIAN_POINT('',(3.610031247503,35.600000001018)); +#239 = CARTESIAN_POINT('',(4.476056652794,37.100000001422)); +#240 = CARTESIAN_POINT('',(5.342082058085,38.600000001825)); +#241 = CARTESIAN_POINT('',(6.208107461466,37.100000000318)); +#242 = CARTESIAN_POINT('',(7.074132864847,35.599999998812)); +#243 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#244 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#245 = ORIENTED_EDGE('',*,*,#246,.F.); +#246 = EDGE_CURVE('',#247,#219,#249,.T.); +#247 = VERTEX_POINT('',#248); +#248 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#249 = SURFACE_CURVE('',#250,(#254,#261),.PCURVE_S1.); +#250 = LINE('',#251,#252); +#251 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#252 = VECTOR('',#253,1.); +#253 = DIRECTION('',(0.,0.,1.)); +#254 = PCURVE('',#100,#255); +#255 = DEFINITIONAL_REPRESENTATION('',(#256),#260); +#256 = LINE('',#257,#258); +#257 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#258 = VECTOR('',#259,1.); +#259 = DIRECTION('',(-0.,-1.)); +#260 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#261 = PCURVE('',#262,#267); +#262 = PLANE('',#263); +#263 = AXIS2_PLACEMENT_3D('',#264,#265,#266); +#264 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#265 = DIRECTION('',(-1.,0.,0.)); +#266 = DIRECTION('',(0.,1.,0.)); +#267 = DEFINITIONAL_REPRESENTATION('',(#268),#272); +#268 = LINE('',#269,#270); +#269 = CARTESIAN_POINT('',(0.,0.)); +#270 = VECTOR('',#271,1.); +#271 = DIRECTION('',(0.,-1.)); +#272 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#273 = ORIENTED_EDGE('',*,*,#274,.F.); +#274 = EDGE_CURVE('',#85,#247,#275,.T.); +#275 = SURFACE_CURVE('',#276,(#281,#288),.PCURVE_S1.); +#276 = CIRCLE('',#277,1.000000000637); +#277 = AXIS2_PLACEMENT_3D('',#278,#279,#280); +#278 = CARTESIAN_POINT('',(-24.00000000063,36.600000000637,0.)); +#279 = DIRECTION('',(0.,0.,1.)); +#280 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#281 = PCURVE('',#100,#282); +#282 = DEFINITIONAL_REPRESENTATION('',(#283),#287); +#283 = LINE('',#284,#285); +#284 = CARTESIAN_POINT('',(-0.,0.)); +#285 = VECTOR('',#286,1.); +#286 = DIRECTION('',(-1.,0.)); +#287 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#288 = PCURVE('',#126,#289); +#289 = DEFINITIONAL_REPRESENTATION('',(#290),#298); +#290 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#291,#292,#293,#294,#295,#296 +,#297),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#291 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#292 = CARTESIAN_POINT('',(3.610031247503,35.600000001018)); +#293 = CARTESIAN_POINT('',(4.476056652794,37.100000001422)); +#294 = CARTESIAN_POINT('',(5.342082058085,38.600000001825)); +#295 = CARTESIAN_POINT('',(6.208107461466,37.100000000318)); +#296 = CARTESIAN_POINT('',(7.074132864847,35.599999998812)); +#297 = CARTESIAN_POINT('',(5.342082056175,35.599999999915)); +#298 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#299 = ADVANCED_FACE('',(#300,#846,#881,#916,#951),#126,.T.); +#300 = FACE_BOUND('',#301,.T.); +#301 = EDGE_LOOP('',(#302,#303,#304,#327,#360,#388,#417,#445,#474,#502, + #531,#559,#588,#616,#645,#673,#702,#730,#763,#791,#824,#845)); +#302 = ORIENTED_EDGE('',*,*,#112,.T.); +#303 = ORIENTED_EDGE('',*,*,#274,.T.); +#304 = ORIENTED_EDGE('',*,*,#305,.T.); +#305 = EDGE_CURVE('',#247,#306,#308,.T.); +#306 = VERTEX_POINT('',#307); +#307 = CARTESIAN_POINT('',(-23.,37.6,0.)); +#308 = SURFACE_CURVE('',#309,(#313,#320),.PCURVE_S1.); +#309 = LINE('',#310,#311); +#310 = CARTESIAN_POINT('',(-23.,36.6,0.)); +#311 = VECTOR('',#312,1.); +#312 = DIRECTION('',(0.,1.,0.)); +#313 = PCURVE('',#126,#314); +#314 = DEFINITIONAL_REPRESENTATION('',(#315),#319); +#315 = LINE('',#316,#317); +#316 = CARTESIAN_POINT('',(4.342082056175,36.599999999915)); +#317 = VECTOR('',#318,1.); +#318 = DIRECTION('',(0.,1.)); +#319 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#320 = PCURVE('',#262,#321); +#321 = DEFINITIONAL_REPRESENTATION('',(#322),#326); +#322 = LINE('',#323,#324); +#323 = CARTESIAN_POINT('',(0.,0.)); +#324 = VECTOR('',#325,1.); +#325 = DIRECTION('',(1.,0.)); +#326 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#327 = ORIENTED_EDGE('',*,*,#328,.T.); +#328 = EDGE_CURVE('',#306,#329,#331,.T.); +#329 = VERTEX_POINT('',#330); +#330 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#331 = SURFACE_CURVE('',#332,(#337,#348),.PCURVE_S1.); +#332 = CIRCLE('',#333,1.000000000637); +#333 = AXIS2_PLACEMENT_3D('',#334,#335,#336); +#334 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,0.)); +#335 = DIRECTION('',(0.,0.,1.)); +#336 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#337 = PCURVE('',#126,#338); +#338 = DEFINITIONAL_REPRESENTATION('',(#339),#347); +#339 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#340,#341,#342,#343,#344,#345 +,#346),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#340 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#341 = CARTESIAN_POINT('',(4.342082057278,39.332050808587)); +#342 = CARTESIAN_POINT('',(5.842082057682,38.466025403295)); +#343 = CARTESIAN_POINT('',(7.342082058085,37.599999998004)); +#344 = CARTESIAN_POINT('',(5.842082056578,36.733974594623)); +#345 = CARTESIAN_POINT('',(4.342082055072,35.867949191243)); +#346 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#347 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#348 = PCURVE('',#349,#354); +#349 = CYLINDRICAL_SURFACE('',#350,1.000000000637); +#350 = AXIS2_PLACEMENT_3D('',#351,#352,#353); +#351 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,0.)); +#352 = DIRECTION('',(-0.,-0.,-1.)); +#353 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#354 = DEFINITIONAL_REPRESENTATION('',(#355),#359); +#355 = LINE('',#356,#357); +#356 = CARTESIAN_POINT('',(-0.,0.)); +#357 = VECTOR('',#358,1.); +#358 = DIRECTION('',(-1.,0.)); +#359 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#360 = ORIENTED_EDGE('',*,*,#361,.T.); +#361 = EDGE_CURVE('',#329,#362,#364,.T.); +#362 = VERTEX_POINT('',#363); +#363 = CARTESIAN_POINT('',(-30.,38.6,0.)); +#364 = SURFACE_CURVE('',#365,(#369,#376),.PCURVE_S1.); +#365 = LINE('',#366,#367); +#366 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#367 = VECTOR('',#368,1.); +#368 = DIRECTION('',(-1.,0.,0.)); +#369 = PCURVE('',#126,#370); +#370 = DEFINITIONAL_REPRESENTATION('',(#371),#375); +#371 = LINE('',#372,#373); +#372 = CARTESIAN_POINT('',(5.342082056175,38.599999999915)); +#373 = VECTOR('',#374,1.); +#374 = DIRECTION('',(1.,0.)); +#375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#376 = PCURVE('',#377,#382); +#377 = PLANE('',#378); +#378 = AXIS2_PLACEMENT_3D('',#379,#380,#381); +#379 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#380 = DIRECTION('',(0.,-1.,0.)); +#381 = DIRECTION('',(-1.,0.,0.)); +#382 = DEFINITIONAL_REPRESENTATION('',(#383),#387); +#383 = LINE('',#384,#385); +#384 = CARTESIAN_POINT('',(0.,-0.)); +#385 = VECTOR('',#386,1.); +#386 = DIRECTION('',(1.,0.)); +#387 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#388 = ORIENTED_EDGE('',*,*,#389,.T.); +#389 = EDGE_CURVE('',#362,#390,#392,.T.); +#390 = VERTEX_POINT('',#391); +#391 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#392 = SURFACE_CURVE('',#393,(#398,#405),.PCURVE_S1.); +#393 = CIRCLE('',#394,2.999999998497); +#394 = AXIS2_PLACEMENT_3D('',#395,#396,#397); +#395 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,0.)); +#396 = DIRECTION('',(0.,0.,-1.)); +#397 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#398 = PCURVE('',#126,#399); +#399 = DEFINITIONAL_REPRESENTATION('',(#400),#404); +#400 = CIRCLE('',#401,2.999999998497); +#401 = AXIS2_PLACEMENT_2D('',#402,#403); +#402 = CARTESIAN_POINT('',(11.342082057678,41.599999998411)); +#403 = DIRECTION('',(-5.011588183996E-10,-1.)); +#404 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#405 = PCURVE('',#406,#411); +#406 = CYLINDRICAL_SURFACE('',#407,2.999999998497); +#407 = AXIS2_PLACEMENT_3D('',#408,#409,#410); +#408 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,0.)); +#409 = DIRECTION('',(0.,0.,-1.)); +#410 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#411 = DEFINITIONAL_REPRESENTATION('',(#412),#416); +#412 = LINE('',#413,#414); +#413 = CARTESIAN_POINT('',(0.,0.)); +#414 = VECTOR('',#415,1.); +#415 = DIRECTION('',(1.,0.)); +#416 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#417 = ORIENTED_EDGE('',*,*,#418,.T.); +#418 = EDGE_CURVE('',#390,#419,#421,.T.); +#419 = VERTEX_POINT('',#420); +#420 = CARTESIAN_POINT('',(-33.,61.6,0.)); +#421 = SURFACE_CURVE('',#422,(#426,#433),.PCURVE_S1.); +#422 = LINE('',#423,#424); +#423 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#424 = VECTOR('',#425,1.); +#425 = DIRECTION('',(0.,1.,0.)); +#426 = PCURVE('',#126,#427); +#427 = DEFINITIONAL_REPRESENTATION('',(#428),#432); +#428 = LINE('',#429,#430); +#429 = CARTESIAN_POINT('',(14.342082056175,41.599999999915)); +#430 = VECTOR('',#431,1.); +#431 = DIRECTION('',(0.,1.)); +#432 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#433 = PCURVE('',#434,#439); +#434 = PLANE('',#435); +#435 = AXIS2_PLACEMENT_3D('',#436,#437,#438); +#436 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#437 = DIRECTION('',(-1.,0.,0.)); +#438 = DIRECTION('',(0.,1.,0.)); +#439 = DEFINITIONAL_REPRESENTATION('',(#440),#444); +#440 = LINE('',#441,#442); +#441 = CARTESIAN_POINT('',(0.,0.)); +#442 = VECTOR('',#443,1.); +#443 = DIRECTION('',(1.,0.)); +#444 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#445 = ORIENTED_EDGE('',*,*,#446,.T.); +#446 = EDGE_CURVE('',#419,#447,#449,.T.); +#447 = VERTEX_POINT('',#448); +#448 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#449 = SURFACE_CURVE('',#450,(#455,#462),.PCURVE_S1.); +#450 = CIRCLE('',#451,2.999999998497); +#451 = AXIS2_PLACEMENT_3D('',#452,#453,#454); +#452 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,0.)); +#453 = DIRECTION('',(0.,0.,-1.)); +#454 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#455 = PCURVE('',#126,#456); +#456 = DEFINITIONAL_REPRESENTATION('',(#457),#461); +#457 = CIRCLE('',#458,2.999999998497); +#458 = AXIS2_PLACEMENT_2D('',#459,#460); +#459 = CARTESIAN_POINT('',(11.342082057678,61.600000001418)); +#460 = DIRECTION('',(1.,-5.011576341617E-10)); +#461 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#462 = PCURVE('',#463,#468); +#463 = CYLINDRICAL_SURFACE('',#464,2.999999998497); +#464 = AXIS2_PLACEMENT_3D('',#465,#466,#467); +#465 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,0.)); +#466 = DIRECTION('',(0.,0.,-1.)); +#467 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#468 = DEFINITIONAL_REPRESENTATION('',(#469),#473); +#469 = LINE('',#470,#471); +#470 = CARTESIAN_POINT('',(0.,0.)); +#471 = VECTOR('',#472,1.); +#472 = DIRECTION('',(1.,0.)); +#473 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#474 = ORIENTED_EDGE('',*,*,#475,.T.); +#475 = EDGE_CURVE('',#447,#476,#478,.T.); +#476 = VERTEX_POINT('',#477); +#477 = CARTESIAN_POINT('',(26.,64.6,0.)); +#478 = SURFACE_CURVE('',#479,(#483,#490),.PCURVE_S1.); +#479 = LINE('',#480,#481); +#480 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#481 = VECTOR('',#482,1.); +#482 = DIRECTION('',(1.,0.,0.)); +#483 = PCURVE('',#126,#484); +#484 = DEFINITIONAL_REPRESENTATION('',(#485),#489); +#485 = LINE('',#486,#487); +#486 = CARTESIAN_POINT('',(11.342082056175,64.599999999915)); +#487 = VECTOR('',#488,1.); +#488 = DIRECTION('',(-1.,0.)); +#489 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#490 = PCURVE('',#491,#496); +#491 = PLANE('',#492); +#492 = AXIS2_PLACEMENT_3D('',#493,#494,#495); +#493 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#494 = DIRECTION('',(0.,1.,0.)); +#495 = DIRECTION('',(1.,0.,0.)); +#496 = DEFINITIONAL_REPRESENTATION('',(#497),#501); +#497 = LINE('',#498,#499); +#498 = CARTESIAN_POINT('',(0.,0.)); +#499 = VECTOR('',#500,1.); +#500 = DIRECTION('',(1.,0.)); +#501 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#502 = ORIENTED_EDGE('',*,*,#503,.T.); +#503 = EDGE_CURVE('',#476,#504,#506,.T.); +#504 = VERTEX_POINT('',#505); +#505 = CARTESIAN_POINT('',(29.,61.6,0.)); +#506 = SURFACE_CURVE('',#507,(#512,#519),.PCURVE_S1.); +#507 = CIRCLE('',#508,2.999999998497); +#508 = AXIS2_PLACEMENT_3D('',#509,#510,#511); +#509 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,0.)); +#510 = DIRECTION('',(0.,0.,-1.)); +#511 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#512 = PCURVE('',#126,#513); +#513 = DEFINITIONAL_REPRESENTATION('',(#514),#518); +#514 = CIRCLE('',#515,2.999999998497); +#515 = AXIS2_PLACEMENT_2D('',#516,#517); +#516 = CARTESIAN_POINT('',(-44.65791794532,61.600000001418)); +#517 = DIRECTION('',(5.011611868754E-10,1.)); +#518 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#519 = PCURVE('',#520,#525); +#520 = CYLINDRICAL_SURFACE('',#521,2.999999998497); +#521 = AXIS2_PLACEMENT_3D('',#522,#523,#524); +#522 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,0.)); +#523 = DIRECTION('',(0.,0.,-1.)); +#524 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#525 = DEFINITIONAL_REPRESENTATION('',(#526),#530); +#526 = LINE('',#527,#528); +#527 = CARTESIAN_POINT('',(0.,0.)); +#528 = VECTOR('',#529,1.); +#529 = DIRECTION('',(1.,0.)); +#530 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#531 = ORIENTED_EDGE('',*,*,#532,.T.); +#532 = EDGE_CURVE('',#504,#533,#535,.T.); +#533 = VERTEX_POINT('',#534); +#534 = CARTESIAN_POINT('',(29.,-61.6,0.)); +#535 = SURFACE_CURVE('',#536,(#540,#547),.PCURVE_S1.); +#536 = LINE('',#537,#538); +#537 = CARTESIAN_POINT('',(29.,61.6,0.)); +#538 = VECTOR('',#539,1.); +#539 = DIRECTION('',(0.,-1.,0.)); +#540 = PCURVE('',#126,#541); +#541 = DEFINITIONAL_REPRESENTATION('',(#542),#546); +#542 = LINE('',#543,#544); +#543 = CARTESIAN_POINT('',(-47.65791794382,61.599999999915)); +#544 = VECTOR('',#545,1.); +#545 = DIRECTION('',(0.,-1.)); +#546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#547 = PCURVE('',#548,#553); +#548 = PLANE('',#549); +#549 = AXIS2_PLACEMENT_3D('',#550,#551,#552); +#550 = CARTESIAN_POINT('',(29.,61.6,0.)); +#551 = DIRECTION('',(1.,0.,-0.)); +#552 = DIRECTION('',(0.,-1.,0.)); +#553 = DEFINITIONAL_REPRESENTATION('',(#554),#558); +#554 = LINE('',#555,#556); +#555 = CARTESIAN_POINT('',(0.,0.)); +#556 = VECTOR('',#557,1.); +#557 = DIRECTION('',(1.,0.)); +#558 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#559 = ORIENTED_EDGE('',*,*,#560,.T.); +#560 = EDGE_CURVE('',#533,#561,#563,.T.); +#561 = VERTEX_POINT('',#562); +#562 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#563 = SURFACE_CURVE('',#564,(#569,#576),.PCURVE_S1.); +#564 = CIRCLE('',#565,3.000000000204); +#565 = AXIS2_PLACEMENT_3D('',#566,#567,#568); +#566 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,0.)); +#567 = DIRECTION('',(0.,0.,-1.)); +#568 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#569 = PCURVE('',#126,#570); +#570 = DEFINITIONAL_REPRESENTATION('',(#571),#575); +#571 = CIRCLE('',#572,3.000000000204); +#572 = AXIS2_PLACEMENT_2D('',#573,#574); +#573 = CARTESIAN_POINT('',(-44.65791794362,-61.59999999988)); +#574 = DIRECTION('',(-1.,-6.787814754256E-11)); +#575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#576 = PCURVE('',#577,#582); +#577 = CYLINDRICAL_SURFACE('',#578,3.000000000204); +#578 = AXIS2_PLACEMENT_3D('',#579,#580,#581); +#579 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,0.)); +#580 = DIRECTION('',(0.,0.,-1.)); +#581 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#582 = DEFINITIONAL_REPRESENTATION('',(#583),#587); +#583 = LINE('',#584,#585); +#584 = CARTESIAN_POINT('',(0.,0.)); +#585 = VECTOR('',#586,1.); +#586 = DIRECTION('',(1.,0.)); +#587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#588 = ORIENTED_EDGE('',*,*,#589,.T.); +#589 = EDGE_CURVE('',#561,#590,#592,.T.); +#590 = VERTEX_POINT('',#591); +#591 = CARTESIAN_POINT('',(-30.,-64.6,0.)); +#592 = SURFACE_CURVE('',#593,(#597,#604),.PCURVE_S1.); +#593 = LINE('',#594,#595); +#594 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#595 = VECTOR('',#596,1.); +#596 = DIRECTION('',(-1.,0.,0.)); +#597 = PCURVE('',#126,#598); +#598 = DEFINITIONAL_REPRESENTATION('',(#599),#603); +#599 = LINE('',#600,#601); +#600 = CARTESIAN_POINT('',(-44.65791794382,-64.60000000008)); +#601 = VECTOR('',#602,1.); +#602 = DIRECTION('',(1.,0.)); +#603 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#604 = PCURVE('',#605,#610); +#605 = PLANE('',#606); +#606 = AXIS2_PLACEMENT_3D('',#607,#608,#609); +#607 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#608 = DIRECTION('',(0.,-1.,0.)); +#609 = DIRECTION('',(-1.,0.,0.)); +#610 = DEFINITIONAL_REPRESENTATION('',(#611),#615); +#611 = LINE('',#612,#613); +#612 = CARTESIAN_POINT('',(0.,-0.)); +#613 = VECTOR('',#614,1.); +#614 = DIRECTION('',(1.,0.)); +#615 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#616 = ORIENTED_EDGE('',*,*,#617,.T.); +#617 = EDGE_CURVE('',#590,#618,#620,.T.); +#618 = VERTEX_POINT('',#619); +#619 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#620 = SURFACE_CURVE('',#621,(#626,#633),.PCURVE_S1.); +#621 = CIRCLE('',#622,2.999999998497); +#622 = AXIS2_PLACEMENT_3D('',#623,#624,#625); +#623 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,0.)); +#624 = DIRECTION('',(0.,0.,-1.)); +#625 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#626 = PCURVE('',#126,#627); +#627 = DEFINITIONAL_REPRESENTATION('',(#628),#632); +#628 = CIRCLE('',#629,2.999999998497); +#629 = AXIS2_PLACEMENT_2D('',#630,#631); +#630 = CARTESIAN_POINT('',(11.342082057678,-61.60000000158)); +#631 = DIRECTION('',(-5.011600026375E-10,-1.)); +#632 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#633 = PCURVE('',#634,#639); +#634 = CYLINDRICAL_SURFACE('',#635,2.999999998497); +#635 = AXIS2_PLACEMENT_3D('',#636,#637,#638); +#636 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,0.)); +#637 = DIRECTION('',(0.,0.,-1.)); +#638 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#639 = DEFINITIONAL_REPRESENTATION('',(#640),#644); +#640 = LINE('',#641,#642); +#641 = CARTESIAN_POINT('',(0.,0.)); +#642 = VECTOR('',#643,1.); +#643 = DIRECTION('',(1.,0.)); +#644 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#645 = ORIENTED_EDGE('',*,*,#646,.T.); +#646 = EDGE_CURVE('',#618,#647,#649,.T.); +#647 = VERTEX_POINT('',#648); +#648 = CARTESIAN_POINT('',(-33.,-41.6,0.)); +#649 = SURFACE_CURVE('',#650,(#654,#661),.PCURVE_S1.); +#650 = LINE('',#651,#652); +#651 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#652 = VECTOR('',#653,1.); +#653 = DIRECTION('',(0.,1.,0.)); +#654 = PCURVE('',#126,#655); +#655 = DEFINITIONAL_REPRESENTATION('',(#656),#660); +#656 = LINE('',#657,#658); +#657 = CARTESIAN_POINT('',(14.342082056175,-61.60000000008)); +#658 = VECTOR('',#659,1.); +#659 = DIRECTION('',(0.,1.)); +#660 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#661 = PCURVE('',#662,#667); +#662 = PLANE('',#663); +#663 = AXIS2_PLACEMENT_3D('',#664,#665,#666); +#664 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#665 = DIRECTION('',(-1.,0.,0.)); +#666 = DIRECTION('',(0.,1.,0.)); +#667 = DEFINITIONAL_REPRESENTATION('',(#668),#672); +#668 = LINE('',#669,#670); +#669 = CARTESIAN_POINT('',(0.,0.)); +#670 = VECTOR('',#671,1.); +#671 = DIRECTION('',(1.,0.)); +#672 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#673 = ORIENTED_EDGE('',*,*,#674,.T.); +#674 = EDGE_CURVE('',#647,#675,#677,.T.); +#675 = VERTEX_POINT('',#676); +#676 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#677 = SURFACE_CURVE('',#678,(#683,#690),.PCURVE_S1.); +#678 = CIRCLE('',#679,2.999999998497); +#679 = AXIS2_PLACEMENT_3D('',#680,#681,#682); +#680 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,0.)); +#681 = DIRECTION('',(0.,0.,-1.)); +#682 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#683 = PCURVE('',#126,#684); +#684 = DEFINITIONAL_REPRESENTATION('',(#685),#689); +#685 = CIRCLE('',#686,2.999999998497); +#686 = AXIS2_PLACEMENT_2D('',#687,#688); +#687 = CARTESIAN_POINT('',(11.342082057678,-41.59999999858)); +#688 = DIRECTION('',(1.,-5.011600026375E-10)); +#689 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#690 = PCURVE('',#691,#696); +#691 = CYLINDRICAL_SURFACE('',#692,2.999999998497); +#692 = AXIS2_PLACEMENT_3D('',#693,#694,#695); +#693 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,0.)); +#694 = DIRECTION('',(0.,0.,-1.)); +#695 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#696 = DEFINITIONAL_REPRESENTATION('',(#697),#701); +#697 = LINE('',#698,#699); +#698 = CARTESIAN_POINT('',(0.,0.)); +#699 = VECTOR('',#700,1.); +#700 = DIRECTION('',(1.,0.)); +#701 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#702 = ORIENTED_EDGE('',*,*,#703,.T.); +#703 = EDGE_CURVE('',#675,#704,#706,.T.); +#704 = VERTEX_POINT('',#705); +#705 = CARTESIAN_POINT('',(-24.,-38.6,0.)); +#706 = SURFACE_CURVE('',#707,(#711,#718),.PCURVE_S1.); +#707 = LINE('',#708,#709); +#708 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#709 = VECTOR('',#710,1.); +#710 = DIRECTION('',(1.,0.,0.)); +#711 = PCURVE('',#126,#712); +#712 = DEFINITIONAL_REPRESENTATION('',(#713),#717); +#713 = LINE('',#714,#715); +#714 = CARTESIAN_POINT('',(11.342082056175,-38.60000000008)); +#715 = VECTOR('',#716,1.); +#716 = DIRECTION('',(-1.,0.)); +#717 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#718 = PCURVE('',#719,#724); +#719 = PLANE('',#720); +#720 = AXIS2_PLACEMENT_3D('',#721,#722,#723); +#721 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#722 = DIRECTION('',(0.,1.,0.)); +#723 = DIRECTION('',(1.,0.,0.)); +#724 = DEFINITIONAL_REPRESENTATION('',(#725),#729); +#725 = LINE('',#726,#727); +#726 = CARTESIAN_POINT('',(0.,0.)); +#727 = VECTOR('',#728,1.); +#728 = DIRECTION('',(1.,0.)); +#729 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#730 = ORIENTED_EDGE('',*,*,#731,.T.); +#731 = EDGE_CURVE('',#704,#732,#734,.T.); +#732 = VERTEX_POINT('',#733); +#733 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#734 = SURFACE_CURVE('',#735,(#740,#751),.PCURVE_S1.); +#735 = CIRCLE('',#736,1.000000000637); +#736 = AXIS2_PLACEMENT_3D('',#737,#738,#739); +#737 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,0.)); +#738 = DIRECTION('',(0.,0.,1.)); +#739 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#740 = PCURVE('',#126,#741); +#741 = DEFINITIONAL_REPRESENTATION('',(#742),#750); +#742 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#743,#744,#745,#746,#747,#748 +,#749),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#743 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#744 = CARTESIAN_POINT('',(3.610031247503,-38.59999999898)); +#745 = CARTESIAN_POINT('',(4.476056652794,-37.09999999857)); +#746 = CARTESIAN_POINT('',(5.342082058085,-35.59999999817)); +#747 = CARTESIAN_POINT('',(6.208107461466,-37.09999999968)); +#748 = CARTESIAN_POINT('',(7.074132864847,-38.60000000118)); +#749 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#750 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#751 = PCURVE('',#752,#757); +#752 = CYLINDRICAL_SURFACE('',#753,1.000000000637); +#753 = AXIS2_PLACEMENT_3D('',#754,#755,#756); +#754 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,0.)); +#755 = DIRECTION('',(-0.,-0.,-1.)); +#756 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#757 = DEFINITIONAL_REPRESENTATION('',(#758),#762); +#758 = LINE('',#759,#760); +#759 = CARTESIAN_POINT('',(-0.,0.)); +#760 = VECTOR('',#761,1.); +#761 = DIRECTION('',(-1.,0.)); +#762 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#763 = ORIENTED_EDGE('',*,*,#764,.T.); +#764 = EDGE_CURVE('',#732,#765,#767,.T.); +#765 = VERTEX_POINT('',#766); +#766 = CARTESIAN_POINT('',(-23.,-36.6,0.)); +#767 = SURFACE_CURVE('',#768,(#772,#779),.PCURVE_S1.); +#768 = LINE('',#769,#770); +#769 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#770 = VECTOR('',#771,1.); +#771 = DIRECTION('',(0.,1.,0.)); +#772 = PCURVE('',#126,#773); +#773 = DEFINITIONAL_REPRESENTATION('',(#774),#778); +#774 = LINE('',#775,#776); +#775 = CARTESIAN_POINT('',(4.342082056175,-37.60000000008)); +#776 = VECTOR('',#777,1.); +#777 = DIRECTION('',(0.,1.)); +#778 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#779 = PCURVE('',#780,#785); +#780 = PLANE('',#781); +#781 = AXIS2_PLACEMENT_3D('',#782,#783,#784); +#782 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#783 = DIRECTION('',(-1.,0.,0.)); +#784 = DIRECTION('',(0.,1.,0.)); +#785 = DEFINITIONAL_REPRESENTATION('',(#786),#790); +#786 = LINE('',#787,#788); +#787 = CARTESIAN_POINT('',(0.,0.)); +#788 = VECTOR('',#789,1.); +#789 = DIRECTION('',(1.,0.)); +#790 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#791 = ORIENTED_EDGE('',*,*,#792,.T.); +#792 = EDGE_CURVE('',#765,#793,#795,.T.); +#793 = VERTEX_POINT('',#794); +#794 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#795 = SURFACE_CURVE('',#796,(#801,#812),.PCURVE_S1.); +#796 = CIRCLE('',#797,1.000000000637); +#797 = AXIS2_PLACEMENT_3D('',#798,#799,#800); +#798 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,0.)); +#799 = DIRECTION('',(0.,0.,1.)); +#800 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#801 = PCURVE('',#126,#802); +#802 = DEFINITIONAL_REPRESENTATION('',(#803),#811); +#803 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#804,#805,#806,#807,#808,#809 +,#810),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#804 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#805 = CARTESIAN_POINT('',(4.342082057278,-34.86794919141)); +#806 = CARTESIAN_POINT('',(5.842082057682,-35.7339745967)); +#807 = CARTESIAN_POINT('',(7.342082058085,-36.60000000199)); +#808 = CARTESIAN_POINT('',(5.842082056578,-37.46602540537)); +#809 = CARTESIAN_POINT('',(4.342082055072,-38.33205080875)); +#810 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#811 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#812 = PCURVE('',#813,#818); +#813 = CYLINDRICAL_SURFACE('',#814,1.000000000637); +#814 = AXIS2_PLACEMENT_3D('',#815,#816,#817); +#815 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,0.)); +#816 = DIRECTION('',(-0.,-0.,-1.)); +#817 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#818 = DEFINITIONAL_REPRESENTATION('',(#819),#823); +#819 = LINE('',#820,#821); +#820 = CARTESIAN_POINT('',(-0.,0.)); +#821 = VECTOR('',#822,1.); +#822 = DIRECTION('',(-1.,0.)); +#823 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#824 = ORIENTED_EDGE('',*,*,#825,.T.); +#825 = EDGE_CURVE('',#793,#142,#826,.T.); +#826 = SURFACE_CURVE('',#827,(#831,#838),.PCURVE_S1.); +#827 = LINE('',#828,#829); +#828 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#829 = VECTOR('',#830,1.); +#830 = DIRECTION('',(-1.,0.,0.)); +#831 = PCURVE('',#126,#832); +#832 = DEFINITIONAL_REPRESENTATION('',(#833),#837); +#833 = LINE('',#834,#835); +#834 = CARTESIAN_POINT('',(5.342082056175,-35.60000000008)); +#835 = VECTOR('',#836,1.); +#836 = DIRECTION('',(1.,0.)); +#837 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#838 = PCURVE('',#159,#839); +#839 = DEFINITIONAL_REPRESENTATION('',(#840),#844); +#840 = LINE('',#841,#842); +#841 = CARTESIAN_POINT('',(0.,-0.)); +#842 = VECTOR('',#843,1.); +#843 = DIRECTION('',(1.,0.)); +#844 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#845 = ORIENTED_EDGE('',*,*,#193,.T.); +#846 = FACE_BOUND('',#847,.T.); +#847 = EDGE_LOOP('',(#848)); +#848 = ORIENTED_EDGE('',*,*,#849,.T.); +#849 = EDGE_CURVE('',#850,#850,#852,.T.); +#850 = VERTEX_POINT('',#851); +#851 = CARTESIAN_POINT('',(28.15,-61.6,0.)); +#852 = SURFACE_CURVE('',#853,(#858,#869),.PCURVE_S1.); +#853 = CIRCLE('',#854,2.15); +#854 = AXIS2_PLACEMENT_3D('',#855,#856,#857); +#855 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#856 = DIRECTION('',(0.,0.,1.)); +#857 = DIRECTION('',(1.,0.,0.)); +#858 = PCURVE('',#126,#859); +#859 = DEFINITIONAL_REPRESENTATION('',(#860),#868); +#860 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#861,#862,#863,#864,#865,#866 +,#867),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#861 = CARTESIAN_POINT('',(-46.80791794382,-61.60000000008)); +#862 = CARTESIAN_POINT('',(-46.80791794382,-57.87609076381)); +#863 = CARTESIAN_POINT('',(-43.58291794382,-59.73804538194)); +#864 = CARTESIAN_POINT('',(-40.35791794382,-61.60000000008)); +#865 = CARTESIAN_POINT('',(-43.58291794382,-63.46195461822)); +#866 = CARTESIAN_POINT('',(-46.80791794382,-65.32390923635)); +#867 = CARTESIAN_POINT('',(-46.80791794382,-61.60000000008)); +#868 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#869 = PCURVE('',#870,#875); +#870 = CYLINDRICAL_SURFACE('',#871,2.15); +#871 = AXIS2_PLACEMENT_3D('',#872,#873,#874); +#872 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#873 = DIRECTION('',(-0.,-0.,-1.)); +#874 = DIRECTION('',(1.,0.,0.)); +#875 = DEFINITIONAL_REPRESENTATION('',(#876),#880); +#876 = LINE('',#877,#878); +#877 = CARTESIAN_POINT('',(-0.,0.)); +#878 = VECTOR('',#879,1.); +#879 = DIRECTION('',(-1.,0.)); +#880 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#881 = FACE_BOUND('',#882,.T.); +#882 = EDGE_LOOP('',(#883)); +#883 = ORIENTED_EDGE('',*,*,#884,.T.); +#884 = EDGE_CURVE('',#885,#885,#887,.T.); +#885 = VERTEX_POINT('',#886); +#886 = CARTESIAN_POINT('',(-27.85,-61.6,0.)); +#887 = SURFACE_CURVE('',#888,(#893,#904),.PCURVE_S1.); +#888 = CIRCLE('',#889,2.15); +#889 = AXIS2_PLACEMENT_3D('',#890,#891,#892); +#890 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#891 = DIRECTION('',(0.,0.,1.)); +#892 = DIRECTION('',(1.,0.,0.)); +#893 = PCURVE('',#126,#894); +#894 = DEFINITIONAL_REPRESENTATION('',(#895),#903); +#895 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#896,#897,#898,#899,#900,#901 +,#902),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#896 = CARTESIAN_POINT('',(9.192082056175,-61.60000000008)); +#897 = CARTESIAN_POINT('',(9.192082056175,-57.87609076381)); +#898 = CARTESIAN_POINT('',(12.417082056175,-59.73804538194)); +#899 = CARTESIAN_POINT('',(15.642082056175,-61.60000000008)); +#900 = CARTESIAN_POINT('',(12.417082056175,-63.46195461822)); +#901 = CARTESIAN_POINT('',(9.192082056175,-65.32390923635)); +#902 = CARTESIAN_POINT('',(9.192082056175,-61.60000000008)); +#903 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#904 = PCURVE('',#905,#910); +#905 = CYLINDRICAL_SURFACE('',#906,2.15); +#906 = AXIS2_PLACEMENT_3D('',#907,#908,#909); +#907 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#908 = DIRECTION('',(-0.,-0.,-1.)); +#909 = DIRECTION('',(1.,0.,0.)); +#910 = DEFINITIONAL_REPRESENTATION('',(#911),#915); +#911 = LINE('',#912,#913); +#912 = CARTESIAN_POINT('',(-0.,0.)); +#913 = VECTOR('',#914,1.); +#914 = DIRECTION('',(-1.,0.)); +#915 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#916 = FACE_BOUND('',#917,.T.); +#917 = EDGE_LOOP('',(#918)); +#918 = ORIENTED_EDGE('',*,*,#919,.T.); +#919 = EDGE_CURVE('',#920,#920,#922,.T.); +#920 = VERTEX_POINT('',#921); +#921 = CARTESIAN_POINT('',(28.15,61.6,0.)); +#922 = SURFACE_CURVE('',#923,(#928,#939),.PCURVE_S1.); +#923 = CIRCLE('',#924,2.15); +#924 = AXIS2_PLACEMENT_3D('',#925,#926,#927); +#925 = CARTESIAN_POINT('',(26.,61.6,0.)); +#926 = DIRECTION('',(0.,0.,1.)); +#927 = DIRECTION('',(1.,0.,0.)); +#928 = PCURVE('',#126,#929); +#929 = DEFINITIONAL_REPRESENTATION('',(#930),#938); +#930 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#931,#932,#933,#934,#935,#936 +,#937),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#931 = CARTESIAN_POINT('',(-46.80791794382,61.599999999915)); +#932 = CARTESIAN_POINT('',(-46.80791794382,65.323909236188)); +#933 = CARTESIAN_POINT('',(-43.58291794382,63.461954618051)); +#934 = CARTESIAN_POINT('',(-40.35791794382,61.599999999915)); +#935 = CARTESIAN_POINT('',(-43.58291794382,59.738045381778)); +#936 = CARTESIAN_POINT('',(-46.80791794382,57.876090763642)); +#937 = CARTESIAN_POINT('',(-46.80791794382,61.599999999915)); +#938 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#939 = PCURVE('',#940,#945); +#940 = CYLINDRICAL_SURFACE('',#941,2.15); +#941 = AXIS2_PLACEMENT_3D('',#942,#943,#944); +#942 = CARTESIAN_POINT('',(26.,61.6,0.)); +#943 = DIRECTION('',(-0.,-0.,-1.)); +#944 = DIRECTION('',(1.,0.,0.)); +#945 = DEFINITIONAL_REPRESENTATION('',(#946),#950); +#946 = LINE('',#947,#948); +#947 = CARTESIAN_POINT('',(-0.,0.)); +#948 = VECTOR('',#949,1.); +#949 = DIRECTION('',(-1.,0.)); +#950 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#951 = FACE_BOUND('',#952,.T.); +#952 = EDGE_LOOP('',(#953)); +#953 = ORIENTED_EDGE('',*,*,#954,.T.); +#954 = EDGE_CURVE('',#955,#955,#957,.T.); +#955 = VERTEX_POINT('',#956); +#956 = CARTESIAN_POINT('',(-27.85,61.6,0.)); +#957 = SURFACE_CURVE('',#958,(#963,#974),.PCURVE_S1.); +#958 = CIRCLE('',#959,2.15); +#959 = AXIS2_PLACEMENT_3D('',#960,#961,#962); +#960 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#961 = DIRECTION('',(0.,0.,1.)); +#962 = DIRECTION('',(1.,0.,0.)); +#963 = PCURVE('',#126,#964); +#964 = DEFINITIONAL_REPRESENTATION('',(#965),#973); +#965 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#966,#967,#968,#969,#970,#971 +,#972),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2,2,2,2,1),( + -2.094395102393,0.,2.094395102393,4.188790204786,6.28318530718, +8.377580409573),.UNSPECIFIED.) CURVE() GEOMETRIC_REPRESENTATION_ITEM() +RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5,1.,0.5,1.)) REPRESENTATION_ITEM( + '') ); +#966 = CARTESIAN_POINT('',(9.192082056175,61.599999999915)); +#967 = CARTESIAN_POINT('',(9.192082056175,65.323909236188)); +#968 = CARTESIAN_POINT('',(12.417082056175,63.461954618051)); +#969 = CARTESIAN_POINT('',(15.642082056175,61.599999999915)); +#970 = CARTESIAN_POINT('',(12.417082056175,59.738045381778)); +#971 = CARTESIAN_POINT('',(9.192082056175,57.876090763642)); +#972 = CARTESIAN_POINT('',(9.192082056175,61.599999999915)); +#973 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#974 = PCURVE('',#975,#980); +#975 = CYLINDRICAL_SURFACE('',#976,2.15); +#976 = AXIS2_PLACEMENT_3D('',#977,#978,#979); +#977 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#978 = DIRECTION('',(-0.,-0.,-1.)); +#979 = DIRECTION('',(1.,0.,0.)); +#980 = DEFINITIONAL_REPRESENTATION('',(#981),#985); +#981 = LINE('',#982,#983); +#982 = CARTESIAN_POINT('',(-0.,0.)); +#983 = VECTOR('',#984,1.); +#984 = DIRECTION('',(-1.,0.)); +#985 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#986 = ADVANCED_FACE('',(#987,#1448,#1483,#1518,#1553),#72,.F.); +#987 = FACE_BOUND('',#988,.F.); +#988 = EDGE_LOOP('',(#989,#990,#991,#1014,#1042,#1065,#1089,#1112,#1136, + #1159,#1183,#1206,#1230,#1253,#1277,#1300,#1324,#1347,#1375,#1398, + #1426,#1447)); +#989 = ORIENTED_EDGE('',*,*,#56,.T.); +#990 = ORIENTED_EDGE('',*,*,#218,.T.); +#991 = ORIENTED_EDGE('',*,*,#992,.T.); +#992 = EDGE_CURVE('',#219,#993,#995,.T.); +#993 = VERTEX_POINT('',#994); +#994 = CARTESIAN_POINT('',(-23.,37.6,4.5)); +#995 = SURFACE_CURVE('',#996,(#1000,#1007),.PCURVE_S1.); +#996 = LINE('',#997,#998); +#997 = CARTESIAN_POINT('',(-23.,36.6,4.5)); +#998 = VECTOR('',#999,1.); +#999 = DIRECTION('',(0.,1.,0.)); +#1000 = PCURVE('',#72,#1001); +#1001 = DEFINITIONAL_REPRESENTATION('',(#1002),#1006); +#1002 = LINE('',#1003,#1004); +#1003 = CARTESIAN_POINT('',(4.342082056175,36.599999999915)); +#1004 = VECTOR('',#1005,1.); +#1005 = DIRECTION('',(0.,1.)); +#1006 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1007 = PCURVE('',#262,#1008); +#1008 = DEFINITIONAL_REPRESENTATION('',(#1009),#1013); +#1009 = LINE('',#1010,#1011); +#1010 = CARTESIAN_POINT('',(0.,-4.5)); +#1011 = VECTOR('',#1012,1.); +#1012 = DIRECTION('',(1.,0.)); +#1013 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1014 = ORIENTED_EDGE('',*,*,#1015,.T.); +#1015 = EDGE_CURVE('',#993,#1016,#1018,.T.); +#1016 = VERTEX_POINT('',#1017); +#1017 = CARTESIAN_POINT('',(-24.,38.6,4.5)); +#1018 = SURFACE_CURVE('',#1019,(#1024,#1035),.PCURVE_S1.); +#1019 = CIRCLE('',#1020,1.000000000637); +#1020 = AXIS2_PLACEMENT_3D('',#1021,#1022,#1023); +#1021 = CARTESIAN_POINT('',(-24.00000000063,37.599999999363,4.5)); +#1022 = DIRECTION('',(0.,0.,1.)); +#1023 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#1024 = PCURVE('',#72,#1025); +#1025 = DEFINITIONAL_REPRESENTATION('',(#1026),#1034); +#1026 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1027,#1028,#1029,#1030, +#1031,#1032,#1033),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1027 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#1028 = CARTESIAN_POINT('',(4.342082057278,39.332050808587)); +#1029 = CARTESIAN_POINT('',(5.842082057682,38.466025403295)); +#1030 = CARTESIAN_POINT('',(7.342082058085,37.599999998004)); +#1031 = CARTESIAN_POINT('',(5.842082056578,36.733974594623)); +#1032 = CARTESIAN_POINT('',(4.342082055072,35.867949191243)); +#1033 = CARTESIAN_POINT('',(4.342082056175,37.599999999915)); +#1034 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1035 = PCURVE('',#349,#1036); +#1036 = DEFINITIONAL_REPRESENTATION('',(#1037),#1041); +#1037 = LINE('',#1038,#1039); +#1038 = CARTESIAN_POINT('',(-0.,-4.5)); +#1039 = VECTOR('',#1040,1.); +#1040 = DIRECTION('',(-1.,0.)); +#1041 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1042 = ORIENTED_EDGE('',*,*,#1043,.T.); +#1043 = EDGE_CURVE('',#1016,#1044,#1046,.T.); +#1044 = VERTEX_POINT('',#1045); +#1045 = CARTESIAN_POINT('',(-30.,38.6,4.5)); +#1046 = SURFACE_CURVE('',#1047,(#1051,#1058),.PCURVE_S1.); +#1047 = LINE('',#1048,#1049); +#1048 = CARTESIAN_POINT('',(-24.,38.6,4.5)); +#1049 = VECTOR('',#1050,1.); +#1050 = DIRECTION('',(-1.,0.,0.)); +#1051 = PCURVE('',#72,#1052); +#1052 = DEFINITIONAL_REPRESENTATION('',(#1053),#1057); +#1053 = LINE('',#1054,#1055); +#1054 = CARTESIAN_POINT('',(5.342082056175,38.599999999915)); +#1055 = VECTOR('',#1056,1.); +#1056 = DIRECTION('',(1.,0.)); +#1057 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1058 = PCURVE('',#377,#1059); +#1059 = DEFINITIONAL_REPRESENTATION('',(#1060),#1064); +#1060 = LINE('',#1061,#1062); +#1061 = CARTESIAN_POINT('',(0.,-4.5)); +#1062 = VECTOR('',#1063,1.); +#1063 = DIRECTION('',(1.,0.)); +#1064 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1065 = ORIENTED_EDGE('',*,*,#1066,.T.); +#1066 = EDGE_CURVE('',#1044,#1067,#1069,.T.); +#1067 = VERTEX_POINT('',#1068); +#1068 = CARTESIAN_POINT('',(-33.,41.6,4.5)); +#1069 = SURFACE_CURVE('',#1070,(#1075,#1082),.PCURVE_S1.); +#1070 = CIRCLE('',#1071,2.999999998497); +#1071 = AXIS2_PLACEMENT_3D('',#1072,#1073,#1074); +#1072 = CARTESIAN_POINT('',(-30.0000000015,41.599999998497,4.5)); +#1073 = DIRECTION('',(0.,0.,-1.)); +#1074 = DIRECTION('',(5.011588183996E-10,-1.,0.)); +#1075 = PCURVE('',#72,#1076); +#1076 = DEFINITIONAL_REPRESENTATION('',(#1077),#1081); +#1077 = CIRCLE('',#1078,2.999999998497); +#1078 = AXIS2_PLACEMENT_2D('',#1079,#1080); +#1079 = CARTESIAN_POINT('',(11.342082057678,41.599999998411)); +#1080 = DIRECTION('',(-5.011588183996E-10,-1.)); +#1081 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1082 = PCURVE('',#406,#1083); +#1083 = DEFINITIONAL_REPRESENTATION('',(#1084),#1088); +#1084 = LINE('',#1085,#1086); +#1085 = CARTESIAN_POINT('',(0.,-4.5)); +#1086 = VECTOR('',#1087,1.); +#1087 = DIRECTION('',(1.,0.)); +#1088 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1089 = ORIENTED_EDGE('',*,*,#1090,.T.); +#1090 = EDGE_CURVE('',#1067,#1091,#1093,.T.); +#1091 = VERTEX_POINT('',#1092); +#1092 = CARTESIAN_POINT('',(-33.,61.6,4.5)); +#1093 = SURFACE_CURVE('',#1094,(#1098,#1105),.PCURVE_S1.); +#1094 = LINE('',#1095,#1096); +#1095 = CARTESIAN_POINT('',(-33.,41.6,4.5)); +#1096 = VECTOR('',#1097,1.); +#1097 = DIRECTION('',(0.,1.,0.)); +#1098 = PCURVE('',#72,#1099); +#1099 = DEFINITIONAL_REPRESENTATION('',(#1100),#1104); +#1100 = LINE('',#1101,#1102); +#1101 = CARTESIAN_POINT('',(14.342082056175,41.599999999915)); +#1102 = VECTOR('',#1103,1.); +#1103 = DIRECTION('',(0.,1.)); +#1104 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1105 = PCURVE('',#434,#1106); +#1106 = DEFINITIONAL_REPRESENTATION('',(#1107),#1111); +#1107 = LINE('',#1108,#1109); +#1108 = CARTESIAN_POINT('',(0.,-4.5)); +#1109 = VECTOR('',#1110,1.); +#1110 = DIRECTION('',(1.,0.)); +#1111 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1112 = ORIENTED_EDGE('',*,*,#1113,.T.); +#1113 = EDGE_CURVE('',#1091,#1114,#1116,.T.); +#1114 = VERTEX_POINT('',#1115); +#1115 = CARTESIAN_POINT('',(-30.,64.6,4.5)); +#1116 = SURFACE_CURVE('',#1117,(#1122,#1129),.PCURVE_S1.); +#1117 = CIRCLE('',#1118,2.999999998497); +#1118 = AXIS2_PLACEMENT_3D('',#1119,#1120,#1121); +#1119 = CARTESIAN_POINT('',(-30.0000000015,61.600000001503,4.5)); +#1120 = DIRECTION('',(0.,0.,-1.)); +#1121 = DIRECTION('',(-1.,-5.011576341617E-10,-0.)); +#1122 = PCURVE('',#72,#1123); +#1123 = DEFINITIONAL_REPRESENTATION('',(#1124),#1128); +#1124 = CIRCLE('',#1125,2.999999998497); +#1125 = AXIS2_PLACEMENT_2D('',#1126,#1127); +#1126 = CARTESIAN_POINT('',(11.342082057678,61.600000001418)); +#1127 = DIRECTION('',(1.,-5.011576341617E-10)); +#1128 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1129 = PCURVE('',#463,#1130); +#1130 = DEFINITIONAL_REPRESENTATION('',(#1131),#1135); +#1131 = LINE('',#1132,#1133); +#1132 = CARTESIAN_POINT('',(0.,-4.5)); +#1133 = VECTOR('',#1134,1.); +#1134 = DIRECTION('',(1.,0.)); +#1135 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1136 = ORIENTED_EDGE('',*,*,#1137,.T.); +#1137 = EDGE_CURVE('',#1114,#1138,#1140,.T.); +#1138 = VERTEX_POINT('',#1139); +#1139 = CARTESIAN_POINT('',(26.,64.6,4.5)); +#1140 = SURFACE_CURVE('',#1141,(#1145,#1152),.PCURVE_S1.); +#1141 = LINE('',#1142,#1143); +#1142 = CARTESIAN_POINT('',(-30.,64.6,4.5)); +#1143 = VECTOR('',#1144,1.); +#1144 = DIRECTION('',(1.,0.,0.)); +#1145 = PCURVE('',#72,#1146); +#1146 = DEFINITIONAL_REPRESENTATION('',(#1147),#1151); +#1147 = LINE('',#1148,#1149); +#1148 = CARTESIAN_POINT('',(11.342082056175,64.599999999915)); +#1149 = VECTOR('',#1150,1.); +#1150 = DIRECTION('',(-1.,0.)); +#1151 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1152 = PCURVE('',#491,#1153); +#1153 = DEFINITIONAL_REPRESENTATION('',(#1154),#1158); +#1154 = LINE('',#1155,#1156); +#1155 = CARTESIAN_POINT('',(0.,-4.5)); +#1156 = VECTOR('',#1157,1.); +#1157 = DIRECTION('',(1.,0.)); +#1158 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1159 = ORIENTED_EDGE('',*,*,#1160,.T.); +#1160 = EDGE_CURVE('',#1138,#1161,#1163,.T.); +#1161 = VERTEX_POINT('',#1162); +#1162 = CARTESIAN_POINT('',(29.,61.6,4.5)); +#1163 = SURFACE_CURVE('',#1164,(#1169,#1176),.PCURVE_S1.); +#1164 = CIRCLE('',#1165,2.999999998497); +#1165 = AXIS2_PLACEMENT_3D('',#1166,#1167,#1168); +#1166 = CARTESIAN_POINT('',(26.000000001503,61.600000001503,4.5)); +#1167 = DIRECTION('',(0.,0.,-1.)); +#1168 = DIRECTION('',(-5.011611868754E-10,1.,0.)); +#1169 = PCURVE('',#72,#1170); +#1170 = DEFINITIONAL_REPRESENTATION('',(#1171),#1175); +#1171 = CIRCLE('',#1172,2.999999998497); +#1172 = AXIS2_PLACEMENT_2D('',#1173,#1174); +#1173 = CARTESIAN_POINT('',(-44.65791794532,61.600000001418)); +#1174 = DIRECTION('',(5.011611868754E-10,1.)); +#1175 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1176 = PCURVE('',#520,#1177); +#1177 = DEFINITIONAL_REPRESENTATION('',(#1178),#1182); +#1178 = LINE('',#1179,#1180); +#1179 = CARTESIAN_POINT('',(0.,-4.5)); +#1180 = VECTOR('',#1181,1.); +#1181 = DIRECTION('',(1.,0.)); +#1182 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1183 = ORIENTED_EDGE('',*,*,#1184,.T.); +#1184 = EDGE_CURVE('',#1161,#1185,#1187,.T.); +#1185 = VERTEX_POINT('',#1186); +#1186 = CARTESIAN_POINT('',(29.,-61.6,4.5)); +#1187 = SURFACE_CURVE('',#1188,(#1192,#1199),.PCURVE_S1.); +#1188 = LINE('',#1189,#1190); +#1189 = CARTESIAN_POINT('',(29.,61.6,4.5)); +#1190 = VECTOR('',#1191,1.); +#1191 = DIRECTION('',(0.,-1.,0.)); +#1192 = PCURVE('',#72,#1193); +#1193 = DEFINITIONAL_REPRESENTATION('',(#1194),#1198); +#1194 = LINE('',#1195,#1196); +#1195 = CARTESIAN_POINT('',(-47.65791794382,61.599999999915)); +#1196 = VECTOR('',#1197,1.); +#1197 = DIRECTION('',(0.,-1.)); +#1198 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1199 = PCURVE('',#548,#1200); +#1200 = DEFINITIONAL_REPRESENTATION('',(#1201),#1205); +#1201 = LINE('',#1202,#1203); +#1202 = CARTESIAN_POINT('',(0.,-4.5)); +#1203 = VECTOR('',#1204,1.); +#1204 = DIRECTION('',(1.,0.)); +#1205 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1206 = ORIENTED_EDGE('',*,*,#1207,.T.); +#1207 = EDGE_CURVE('',#1185,#1208,#1210,.T.); +#1208 = VERTEX_POINT('',#1209); +#1209 = CARTESIAN_POINT('',(26.,-64.6,4.5)); +#1210 = SURFACE_CURVE('',#1211,(#1216,#1223),.PCURVE_S1.); +#1211 = CIRCLE('',#1212,3.000000000204); +#1212 = AXIS2_PLACEMENT_3D('',#1213,#1214,#1215); +#1213 = CARTESIAN_POINT('',(25.999999999796,-61.59999999979,4.5)); +#1214 = DIRECTION('',(0.,0.,-1.)); +#1215 = DIRECTION('',(1.,-6.787814754256E-11,0.)); +#1216 = PCURVE('',#72,#1217); +#1217 = DEFINITIONAL_REPRESENTATION('',(#1218),#1222); +#1218 = CIRCLE('',#1219,3.000000000204); +#1219 = AXIS2_PLACEMENT_2D('',#1220,#1221); +#1220 = CARTESIAN_POINT('',(-44.65791794362,-61.59999999988)); +#1221 = DIRECTION('',(-1.,-6.787814754256E-11)); +#1222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1223 = PCURVE('',#577,#1224); +#1224 = DEFINITIONAL_REPRESENTATION('',(#1225),#1229); +#1225 = LINE('',#1226,#1227); +#1226 = CARTESIAN_POINT('',(0.,-4.5)); +#1227 = VECTOR('',#1228,1.); +#1228 = DIRECTION('',(1.,0.)); +#1229 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1230 = ORIENTED_EDGE('',*,*,#1231,.T.); +#1231 = EDGE_CURVE('',#1208,#1232,#1234,.T.); +#1232 = VERTEX_POINT('',#1233); +#1233 = CARTESIAN_POINT('',(-30.,-64.6,4.5)); +#1234 = SURFACE_CURVE('',#1235,(#1239,#1246),.PCURVE_S1.); +#1235 = LINE('',#1236,#1237); +#1236 = CARTESIAN_POINT('',(26.,-64.6,4.5)); +#1237 = VECTOR('',#1238,1.); +#1238 = DIRECTION('',(-1.,0.,0.)); +#1239 = PCURVE('',#72,#1240); +#1240 = DEFINITIONAL_REPRESENTATION('',(#1241),#1245); +#1241 = LINE('',#1242,#1243); +#1242 = CARTESIAN_POINT('',(-44.65791794382,-64.60000000008)); +#1243 = VECTOR('',#1244,1.); +#1244 = DIRECTION('',(1.,0.)); +#1245 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1246 = PCURVE('',#605,#1247); +#1247 = DEFINITIONAL_REPRESENTATION('',(#1248),#1252); +#1248 = LINE('',#1249,#1250); +#1249 = CARTESIAN_POINT('',(0.,-4.5)); +#1250 = VECTOR('',#1251,1.); +#1251 = DIRECTION('',(1.,0.)); +#1252 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1253 = ORIENTED_EDGE('',*,*,#1254,.T.); +#1254 = EDGE_CURVE('',#1232,#1255,#1257,.T.); +#1255 = VERTEX_POINT('',#1256); +#1256 = CARTESIAN_POINT('',(-33.,-61.6,4.5)); +#1257 = SURFACE_CURVE('',#1258,(#1263,#1270),.PCURVE_S1.); +#1258 = CIRCLE('',#1259,2.999999998497); +#1259 = AXIS2_PLACEMENT_3D('',#1260,#1261,#1262); +#1260 = CARTESIAN_POINT('',(-30.0000000015,-61.6000000015,4.5)); +#1261 = DIRECTION('',(0.,0.,-1.)); +#1262 = DIRECTION('',(5.011600026375E-10,-1.,0.)); +#1263 = PCURVE('',#72,#1264); +#1264 = DEFINITIONAL_REPRESENTATION('',(#1265),#1269); +#1265 = CIRCLE('',#1266,2.999999998497); +#1266 = AXIS2_PLACEMENT_2D('',#1267,#1268); +#1267 = CARTESIAN_POINT('',(11.342082057678,-61.60000000158)); +#1268 = DIRECTION('',(-5.011600026375E-10,-1.)); +#1269 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1270 = PCURVE('',#634,#1271); +#1271 = DEFINITIONAL_REPRESENTATION('',(#1272),#1276); +#1272 = LINE('',#1273,#1274); +#1273 = CARTESIAN_POINT('',(0.,-4.5)); +#1274 = VECTOR('',#1275,1.); +#1275 = DIRECTION('',(1.,0.)); +#1276 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1277 = ORIENTED_EDGE('',*,*,#1278,.T.); +#1278 = EDGE_CURVE('',#1255,#1279,#1281,.T.); +#1279 = VERTEX_POINT('',#1280); +#1280 = CARTESIAN_POINT('',(-33.,-41.6,4.5)); +#1281 = SURFACE_CURVE('',#1282,(#1286,#1293),.PCURVE_S1.); +#1282 = LINE('',#1283,#1284); +#1283 = CARTESIAN_POINT('',(-33.,-61.6,4.5)); +#1284 = VECTOR('',#1285,1.); +#1285 = DIRECTION('',(0.,1.,0.)); +#1286 = PCURVE('',#72,#1287); +#1287 = DEFINITIONAL_REPRESENTATION('',(#1288),#1292); +#1288 = LINE('',#1289,#1290); +#1289 = CARTESIAN_POINT('',(14.342082056175,-61.60000000008)); +#1290 = VECTOR('',#1291,1.); +#1291 = DIRECTION('',(0.,1.)); +#1292 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1293 = PCURVE('',#662,#1294); +#1294 = DEFINITIONAL_REPRESENTATION('',(#1295),#1299); +#1295 = LINE('',#1296,#1297); +#1296 = CARTESIAN_POINT('',(0.,-4.5)); +#1297 = VECTOR('',#1298,1.); +#1298 = DIRECTION('',(1.,0.)); +#1299 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1300 = ORIENTED_EDGE('',*,*,#1301,.T.); +#1301 = EDGE_CURVE('',#1279,#1302,#1304,.T.); +#1302 = VERTEX_POINT('',#1303); +#1303 = CARTESIAN_POINT('',(-30.,-38.6,4.5)); +#1304 = SURFACE_CURVE('',#1305,(#1310,#1317),.PCURVE_S1.); +#1305 = CIRCLE('',#1306,2.999999998497); +#1306 = AXIS2_PLACEMENT_3D('',#1307,#1308,#1309); +#1307 = CARTESIAN_POINT('',(-30.0000000015,-41.59999999849,4.5)); +#1308 = DIRECTION('',(0.,0.,-1.)); +#1309 = DIRECTION('',(-1.,-5.011600026375E-10,-0.)); +#1310 = PCURVE('',#72,#1311); +#1311 = DEFINITIONAL_REPRESENTATION('',(#1312),#1316); +#1312 = CIRCLE('',#1313,2.999999998497); +#1313 = AXIS2_PLACEMENT_2D('',#1314,#1315); +#1314 = CARTESIAN_POINT('',(11.342082057678,-41.59999999858)); +#1315 = DIRECTION('',(1.,-5.011600026375E-10)); +#1316 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1317 = PCURVE('',#691,#1318); +#1318 = DEFINITIONAL_REPRESENTATION('',(#1319),#1323); +#1319 = LINE('',#1320,#1321); +#1320 = CARTESIAN_POINT('',(0.,-4.5)); +#1321 = VECTOR('',#1322,1.); +#1322 = DIRECTION('',(1.,0.)); +#1323 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1324 = ORIENTED_EDGE('',*,*,#1325,.T.); +#1325 = EDGE_CURVE('',#1302,#1326,#1328,.T.); +#1326 = VERTEX_POINT('',#1327); +#1327 = CARTESIAN_POINT('',(-24.,-38.6,4.5)); +#1328 = SURFACE_CURVE('',#1329,(#1333,#1340),.PCURVE_S1.); +#1329 = LINE('',#1330,#1331); +#1330 = CARTESIAN_POINT('',(-30.,-38.6,4.5)); +#1331 = VECTOR('',#1332,1.); +#1332 = DIRECTION('',(1.,0.,0.)); +#1333 = PCURVE('',#72,#1334); +#1334 = DEFINITIONAL_REPRESENTATION('',(#1335),#1339); +#1335 = LINE('',#1336,#1337); +#1336 = CARTESIAN_POINT('',(11.342082056175,-38.60000000008)); +#1337 = VECTOR('',#1338,1.); +#1338 = DIRECTION('',(-1.,0.)); +#1339 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1340 = PCURVE('',#719,#1341); +#1341 = DEFINITIONAL_REPRESENTATION('',(#1342),#1346); +#1342 = LINE('',#1343,#1344); +#1343 = CARTESIAN_POINT('',(0.,-4.5)); +#1344 = VECTOR('',#1345,1.); +#1345 = DIRECTION('',(1.,0.)); +#1346 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1347 = ORIENTED_EDGE('',*,*,#1348,.T.); +#1348 = EDGE_CURVE('',#1326,#1349,#1351,.T.); +#1349 = VERTEX_POINT('',#1350); +#1350 = CARTESIAN_POINT('',(-23.,-37.6,4.5)); +#1351 = SURFACE_CURVE('',#1352,(#1357,#1368),.PCURVE_S1.); +#1352 = CIRCLE('',#1353,1.000000000637); +#1353 = AXIS2_PLACEMENT_3D('',#1354,#1355,#1356); +#1354 = CARTESIAN_POINT('',(-24.00000000063,-37.59999999936,4.5)); +#1355 = DIRECTION('',(0.,0.,1.)); +#1356 = DIRECTION('',(6.369127443613E-10,-1.,0.)); +#1357 = PCURVE('',#72,#1358); +#1358 = DEFINITIONAL_REPRESENTATION('',(#1359),#1367); +#1359 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1360,#1361,#1362,#1363, +#1364,#1365,#1366),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1360 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#1361 = CARTESIAN_POINT('',(3.610031247503,-38.59999999898)); +#1362 = CARTESIAN_POINT('',(4.476056652794,-37.09999999857)); +#1363 = CARTESIAN_POINT('',(5.342082058085,-35.59999999817)); +#1364 = CARTESIAN_POINT('',(6.208107461466,-37.09999999968)); +#1365 = CARTESIAN_POINT('',(7.074132864847,-38.60000000118)); +#1366 = CARTESIAN_POINT('',(5.342082056175,-38.60000000008)); +#1367 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1368 = PCURVE('',#752,#1369); +#1369 = DEFINITIONAL_REPRESENTATION('',(#1370),#1374); +#1370 = LINE('',#1371,#1372); +#1371 = CARTESIAN_POINT('',(-0.,-4.5)); +#1372 = VECTOR('',#1373,1.); +#1373 = DIRECTION('',(-1.,0.)); +#1374 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1375 = ORIENTED_EDGE('',*,*,#1376,.T.); +#1376 = EDGE_CURVE('',#1349,#1377,#1379,.T.); +#1377 = VERTEX_POINT('',#1378); +#1378 = CARTESIAN_POINT('',(-23.,-36.6,4.5)); +#1379 = SURFACE_CURVE('',#1380,(#1384,#1391),.PCURVE_S1.); +#1380 = LINE('',#1381,#1382); +#1381 = CARTESIAN_POINT('',(-23.,-37.6,4.5)); +#1382 = VECTOR('',#1383,1.); +#1383 = DIRECTION('',(0.,1.,0.)); +#1384 = PCURVE('',#72,#1385); +#1385 = DEFINITIONAL_REPRESENTATION('',(#1386),#1390); +#1386 = LINE('',#1387,#1388); +#1387 = CARTESIAN_POINT('',(4.342082056175,-37.60000000008)); +#1388 = VECTOR('',#1389,1.); +#1389 = DIRECTION('',(0.,1.)); +#1390 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1391 = PCURVE('',#780,#1392); +#1392 = DEFINITIONAL_REPRESENTATION('',(#1393),#1397); +#1393 = LINE('',#1394,#1395); +#1394 = CARTESIAN_POINT('',(0.,-4.5)); +#1395 = VECTOR('',#1396,1.); +#1396 = DIRECTION('',(1.,0.)); +#1397 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1398 = ORIENTED_EDGE('',*,*,#1399,.T.); +#1399 = EDGE_CURVE('',#1377,#1400,#1402,.T.); +#1400 = VERTEX_POINT('',#1401); +#1401 = CARTESIAN_POINT('',(-24.,-35.6,4.5)); +#1402 = SURFACE_CURVE('',#1403,(#1408,#1419),.PCURVE_S1.); +#1403 = CIRCLE('',#1404,1.000000000637); +#1404 = AXIS2_PLACEMENT_3D('',#1405,#1406,#1407); +#1405 = CARTESIAN_POINT('',(-24.00000000063,-36.60000000063,4.5)); +#1406 = DIRECTION('',(0.,0.,1.)); +#1407 = DIRECTION('',(1.,6.369091916476E-10,-0.)); +#1408 = PCURVE('',#72,#1409); +#1409 = DEFINITIONAL_REPRESENTATION('',(#1410),#1418); +#1410 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1411,#1412,#1413,#1414, +#1415,#1416,#1417),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1411 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#1412 = CARTESIAN_POINT('',(4.342082057278,-34.86794919141)); +#1413 = CARTESIAN_POINT('',(5.842082057682,-35.7339745967)); +#1414 = CARTESIAN_POINT('',(7.342082058085,-36.60000000199)); +#1415 = CARTESIAN_POINT('',(5.842082056578,-37.46602540537)); +#1416 = CARTESIAN_POINT('',(4.342082055072,-38.33205080875)); +#1417 = CARTESIAN_POINT('',(4.342082056175,-36.60000000008)); +#1418 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1419 = PCURVE('',#813,#1420); +#1420 = DEFINITIONAL_REPRESENTATION('',(#1421),#1425); +#1421 = LINE('',#1422,#1423); +#1422 = CARTESIAN_POINT('',(-0.,-4.5)); +#1423 = VECTOR('',#1424,1.); +#1424 = DIRECTION('',(-1.,0.)); +#1425 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1426 = ORIENTED_EDGE('',*,*,#1427,.T.); +#1427 = EDGE_CURVE('',#1400,#144,#1428,.T.); +#1428 = SURFACE_CURVE('',#1429,(#1433,#1440),.PCURVE_S1.); +#1429 = LINE('',#1430,#1431); +#1430 = CARTESIAN_POINT('',(-24.,-35.6,4.5)); +#1431 = VECTOR('',#1432,1.); +#1432 = DIRECTION('',(-1.,0.,0.)); +#1433 = PCURVE('',#72,#1434); +#1434 = DEFINITIONAL_REPRESENTATION('',(#1435),#1439); +#1435 = LINE('',#1436,#1437); +#1436 = CARTESIAN_POINT('',(5.342082056175,-35.60000000008)); +#1437 = VECTOR('',#1438,1.); +#1438 = DIRECTION('',(1.,0.)); +#1439 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1440 = PCURVE('',#159,#1441); +#1441 = DEFINITIONAL_REPRESENTATION('',(#1442),#1446); +#1442 = LINE('',#1443,#1444); +#1443 = CARTESIAN_POINT('',(0.,-4.5)); +#1444 = VECTOR('',#1445,1.); +#1445 = DIRECTION('',(1.,0.)); +#1446 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1447 = ORIENTED_EDGE('',*,*,#171,.T.); +#1448 = FACE_BOUND('',#1449,.F.); +#1449 = EDGE_LOOP('',(#1450)); +#1450 = ORIENTED_EDGE('',*,*,#1451,.T.); +#1451 = EDGE_CURVE('',#1452,#1452,#1454,.T.); +#1452 = VERTEX_POINT('',#1453); +#1453 = CARTESIAN_POINT('',(27.15,-61.6,4.5)); +#1454 = SURFACE_CURVE('',#1455,(#1460,#1471),.PCURVE_S1.); +#1455 = CIRCLE('',#1456,1.15); +#1456 = AXIS2_PLACEMENT_3D('',#1457,#1458,#1459); +#1457 = CARTESIAN_POINT('',(26.,-61.6,4.5)); +#1458 = DIRECTION('',(0.,0.,1.)); +#1459 = DIRECTION('',(1.,0.,0.)); +#1460 = PCURVE('',#72,#1461); +#1461 = DEFINITIONAL_REPRESENTATION('',(#1462),#1470); +#1462 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1463,#1464,#1465,#1466, +#1467,#1468,#1469),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1463 = CARTESIAN_POINT('',(-45.80791794382,-61.60000000008)); +#1464 = CARTESIAN_POINT('',(-45.80791794382,-59.60814157138)); +#1465 = CARTESIAN_POINT('',(-44.08291794382,-60.60407078573)); +#1466 = CARTESIAN_POINT('',(-42.35791794382,-61.60000000008)); +#1467 = CARTESIAN_POINT('',(-44.08291794382,-62.59592921443)); +#1468 = CARTESIAN_POINT('',(-45.80791794382,-63.59185842879)); +#1469 = CARTESIAN_POINT('',(-45.80791794382,-61.60000000008)); +#1470 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1471 = PCURVE('',#1472,#1477); +#1472 = CYLINDRICAL_SURFACE('',#1473,1.15); +#1473 = AXIS2_PLACEMENT_3D('',#1474,#1475,#1476); +#1474 = CARTESIAN_POINT('',(26.,-61.6,0.)); +#1475 = DIRECTION('',(-0.,-0.,-1.)); +#1476 = DIRECTION('',(1.,0.,0.)); +#1477 = DEFINITIONAL_REPRESENTATION('',(#1478),#1482); +#1478 = LINE('',#1479,#1480); +#1479 = CARTESIAN_POINT('',(-0.,-4.5)); +#1480 = VECTOR('',#1481,1.); +#1481 = DIRECTION('',(-1.,0.)); +#1482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1483 = FACE_BOUND('',#1484,.F.); +#1484 = EDGE_LOOP('',(#1485)); +#1485 = ORIENTED_EDGE('',*,*,#1486,.T.); +#1486 = EDGE_CURVE('',#1487,#1487,#1489,.T.); +#1487 = VERTEX_POINT('',#1488); +#1488 = CARTESIAN_POINT('',(-28.85,-61.6,4.5)); +#1489 = SURFACE_CURVE('',#1490,(#1495,#1506),.PCURVE_S1.); +#1490 = CIRCLE('',#1491,1.15); +#1491 = AXIS2_PLACEMENT_3D('',#1492,#1493,#1494); +#1492 = CARTESIAN_POINT('',(-30.,-61.6,4.5)); +#1493 = DIRECTION('',(0.,0.,1.)); +#1494 = DIRECTION('',(1.,0.,0.)); +#1495 = PCURVE('',#72,#1496); +#1496 = DEFINITIONAL_REPRESENTATION('',(#1497),#1505); +#1497 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1498,#1499,#1500,#1501, +#1502,#1503,#1504),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1498 = CARTESIAN_POINT('',(10.192082056175,-61.60000000008)); +#1499 = CARTESIAN_POINT('',(10.192082056175,-59.60814157138)); +#1500 = CARTESIAN_POINT('',(11.917082056175,-60.60407078573)); +#1501 = CARTESIAN_POINT('',(13.642082056175,-61.60000000008)); +#1502 = CARTESIAN_POINT('',(11.917082056175,-62.59592921443)); +#1503 = CARTESIAN_POINT('',(10.192082056175,-63.59185842879)); +#1504 = CARTESIAN_POINT('',(10.192082056175,-61.60000000008)); +#1505 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1506 = PCURVE('',#1507,#1512); +#1507 = CYLINDRICAL_SURFACE('',#1508,1.15); +#1508 = AXIS2_PLACEMENT_3D('',#1509,#1510,#1511); +#1509 = CARTESIAN_POINT('',(-30.,-61.6,0.)); +#1510 = DIRECTION('',(-0.,-0.,-1.)); +#1511 = DIRECTION('',(1.,0.,0.)); +#1512 = DEFINITIONAL_REPRESENTATION('',(#1513),#1517); +#1513 = LINE('',#1514,#1515); +#1514 = CARTESIAN_POINT('',(-0.,-4.5)); +#1515 = VECTOR('',#1516,1.); +#1516 = DIRECTION('',(-1.,0.)); +#1517 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1518 = FACE_BOUND('',#1519,.F.); +#1519 = EDGE_LOOP('',(#1520)); +#1520 = ORIENTED_EDGE('',*,*,#1521,.T.); +#1521 = EDGE_CURVE('',#1522,#1522,#1524,.T.); +#1522 = VERTEX_POINT('',#1523); +#1523 = CARTESIAN_POINT('',(27.15,61.6,4.5)); +#1524 = SURFACE_CURVE('',#1525,(#1530,#1541),.PCURVE_S1.); +#1525 = CIRCLE('',#1526,1.15); +#1526 = AXIS2_PLACEMENT_3D('',#1527,#1528,#1529); +#1527 = CARTESIAN_POINT('',(26.,61.6,4.5)); +#1528 = DIRECTION('',(0.,0.,1.)); +#1529 = DIRECTION('',(1.,0.,0.)); +#1530 = PCURVE('',#72,#1531); +#1531 = DEFINITIONAL_REPRESENTATION('',(#1532),#1540); +#1532 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1533,#1534,#1535,#1536, +#1537,#1538,#1539),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1533 = CARTESIAN_POINT('',(-45.80791794382,61.599999999915)); +#1534 = CARTESIAN_POINT('',(-45.80791794382,63.591858428619)); +#1535 = CARTESIAN_POINT('',(-44.08291794382,62.595929214267)); +#1536 = CARTESIAN_POINT('',(-42.35791794382,61.599999999915)); +#1537 = CARTESIAN_POINT('',(-44.08291794382,60.604070785563)); +#1538 = CARTESIAN_POINT('',(-45.80791794382,59.60814157121)); +#1539 = CARTESIAN_POINT('',(-45.80791794382,61.599999999915)); +#1540 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1541 = PCURVE('',#1542,#1547); +#1542 = CYLINDRICAL_SURFACE('',#1543,1.15); +#1543 = AXIS2_PLACEMENT_3D('',#1544,#1545,#1546); +#1544 = CARTESIAN_POINT('',(26.,61.6,0.)); +#1545 = DIRECTION('',(-0.,-0.,-1.)); +#1546 = DIRECTION('',(1.,0.,0.)); +#1547 = DEFINITIONAL_REPRESENTATION('',(#1548),#1552); +#1548 = LINE('',#1549,#1550); +#1549 = CARTESIAN_POINT('',(-0.,-4.5)); +#1550 = VECTOR('',#1551,1.); +#1551 = DIRECTION('',(-1.,0.)); +#1552 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1553 = FACE_BOUND('',#1554,.F.); +#1554 = EDGE_LOOP('',(#1555)); +#1555 = ORIENTED_EDGE('',*,*,#1556,.T.); +#1556 = EDGE_CURVE('',#1557,#1557,#1559,.T.); +#1557 = VERTEX_POINT('',#1558); +#1558 = CARTESIAN_POINT('',(-28.85,61.6,4.5)); +#1559 = SURFACE_CURVE('',#1560,(#1565,#1576),.PCURVE_S1.); +#1560 = CIRCLE('',#1561,1.15); +#1561 = AXIS2_PLACEMENT_3D('',#1562,#1563,#1564); +#1562 = CARTESIAN_POINT('',(-30.,61.6,4.5)); +#1563 = DIRECTION('',(0.,0.,1.)); +#1564 = DIRECTION('',(1.,0.,0.)); +#1565 = PCURVE('',#72,#1566); +#1566 = DEFINITIONAL_REPRESENTATION('',(#1567),#1575); +#1567 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#1568,#1569,#1570,#1571, +#1572,#1573,#1574),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#1568 = CARTESIAN_POINT('',(10.192082056175,61.599999999915)); +#1569 = CARTESIAN_POINT('',(10.192082056175,63.591858428619)); +#1570 = CARTESIAN_POINT('',(11.917082056175,62.595929214267)); +#1571 = CARTESIAN_POINT('',(13.642082056175,61.599999999915)); +#1572 = CARTESIAN_POINT('',(11.917082056175,60.604070785563)); +#1573 = CARTESIAN_POINT('',(10.192082056175,59.60814157121)); +#1574 = CARTESIAN_POINT('',(10.192082056175,61.599999999915)); +#1575 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1576 = PCURVE('',#1577,#1582); +#1577 = CYLINDRICAL_SURFACE('',#1578,1.15); +#1578 = AXIS2_PLACEMENT_3D('',#1579,#1580,#1581); +#1579 = CARTESIAN_POINT('',(-30.,61.6,0.)); +#1580 = DIRECTION('',(-0.,-0.,-1.)); +#1581 = DIRECTION('',(1.,0.,0.)); +#1582 = DEFINITIONAL_REPRESENTATION('',(#1583),#1587); +#1583 = LINE('',#1584,#1585); +#1584 = CARTESIAN_POINT('',(-0.,-4.5)); +#1585 = VECTOR('',#1586,1.); +#1586 = DIRECTION('',(-1.,0.)); +#1587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1588 = ADVANCED_FACE('',(#1589),#159,.T.); +#1589 = FACE_BOUND('',#1590,.T.); +#1590 = EDGE_LOOP('',(#1591,#1612,#1613,#1614)); +#1591 = ORIENTED_EDGE('',*,*,#1592,.T.); +#1592 = EDGE_CURVE('',#793,#1400,#1593,.T.); +#1593 = SURFACE_CURVE('',#1594,(#1598,#1605),.PCURVE_S1.); +#1594 = LINE('',#1595,#1596); +#1595 = CARTESIAN_POINT('',(-24.,-35.6,0.)); +#1596 = VECTOR('',#1597,1.); +#1597 = DIRECTION('',(0.,0.,1.)); +#1598 = PCURVE('',#159,#1599); +#1599 = DEFINITIONAL_REPRESENTATION('',(#1600),#1604); +#1600 = LINE('',#1601,#1602); +#1601 = CARTESIAN_POINT('',(0.,-0.)); +#1602 = VECTOR('',#1603,1.); +#1603 = DIRECTION('',(0.,-1.)); +#1604 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1605 = PCURVE('',#813,#1606); +#1606 = DEFINITIONAL_REPRESENTATION('',(#1607),#1611); +#1607 = LINE('',#1608,#1609); +#1608 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1609 = VECTOR('',#1610,1.); +#1610 = DIRECTION('',(-0.,-1.)); +#1611 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1612 = ORIENTED_EDGE('',*,*,#1427,.T.); +#1613 = ORIENTED_EDGE('',*,*,#141,.F.); +#1614 = ORIENTED_EDGE('',*,*,#825,.F.); +#1615 = ADVANCED_FACE('',(#1616),#262,.T.); +#1616 = FACE_BOUND('',#1617,.T.); +#1617 = EDGE_LOOP('',(#1618,#1619,#1620,#1641)); +#1618 = ORIENTED_EDGE('',*,*,#246,.T.); +#1619 = ORIENTED_EDGE('',*,*,#992,.T.); +#1620 = ORIENTED_EDGE('',*,*,#1621,.F.); +#1621 = EDGE_CURVE('',#306,#993,#1622,.T.); +#1622 = SURFACE_CURVE('',#1623,(#1627,#1634),.PCURVE_S1.); +#1623 = LINE('',#1624,#1625); +#1624 = CARTESIAN_POINT('',(-23.,37.6,0.)); +#1625 = VECTOR('',#1626,1.); +#1626 = DIRECTION('',(0.,0.,1.)); +#1627 = PCURVE('',#262,#1628); +#1628 = DEFINITIONAL_REPRESENTATION('',(#1629),#1633); +#1629 = LINE('',#1630,#1631); +#1630 = CARTESIAN_POINT('',(1.,0.)); +#1631 = VECTOR('',#1632,1.); +#1632 = DIRECTION('',(0.,-1.)); +#1633 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1634 = PCURVE('',#349,#1635); +#1635 = DEFINITIONAL_REPRESENTATION('',(#1636),#1640); +#1636 = LINE('',#1637,#1638); +#1637 = CARTESIAN_POINT('',(-0.,0.)); +#1638 = VECTOR('',#1639,1.); +#1639 = DIRECTION('',(-0.,-1.)); +#1640 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1641 = ORIENTED_EDGE('',*,*,#305,.F.); +#1642 = ADVANCED_FACE('',(#1643),#813,.F.); +#1643 = FACE_BOUND('',#1644,.T.); +#1644 = EDGE_LOOP('',(#1645,#1666,#1667,#1668)); +#1645 = ORIENTED_EDGE('',*,*,#1646,.T.); +#1646 = EDGE_CURVE('',#765,#1377,#1647,.T.); +#1647 = SURFACE_CURVE('',#1648,(#1652,#1659),.PCURVE_S1.); +#1648 = LINE('',#1649,#1650); +#1649 = CARTESIAN_POINT('',(-23.,-36.6,0.)); +#1650 = VECTOR('',#1651,1.); +#1651 = DIRECTION('',(0.,0.,1.)); +#1652 = PCURVE('',#813,#1653); +#1653 = DEFINITIONAL_REPRESENTATION('',(#1654),#1658); +#1654 = LINE('',#1655,#1656); +#1655 = CARTESIAN_POINT('',(-0.,0.)); +#1656 = VECTOR('',#1657,1.); +#1657 = DIRECTION('',(-0.,-1.)); +#1658 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1659 = PCURVE('',#780,#1660); +#1660 = DEFINITIONAL_REPRESENTATION('',(#1661),#1665); +#1661 = LINE('',#1662,#1663); +#1662 = CARTESIAN_POINT('',(1.,0.)); +#1663 = VECTOR('',#1664,1.); +#1664 = DIRECTION('',(0.,-1.)); +#1665 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1666 = ORIENTED_EDGE('',*,*,#1399,.T.); +#1667 = ORIENTED_EDGE('',*,*,#1592,.F.); +#1668 = ORIENTED_EDGE('',*,*,#792,.F.); +#1669 = ADVANCED_FACE('',(#1670),#349,.F.); +#1670 = FACE_BOUND('',#1671,.T.); +#1671 = EDGE_LOOP('',(#1672,#1673,#1674,#1695)); +#1672 = ORIENTED_EDGE('',*,*,#1621,.T.); +#1673 = ORIENTED_EDGE('',*,*,#1015,.T.); +#1674 = ORIENTED_EDGE('',*,*,#1675,.F.); +#1675 = EDGE_CURVE('',#329,#1016,#1676,.T.); +#1676 = SURFACE_CURVE('',#1677,(#1681,#1688),.PCURVE_S1.); +#1677 = LINE('',#1678,#1679); +#1678 = CARTESIAN_POINT('',(-24.,38.6,0.)); +#1679 = VECTOR('',#1680,1.); +#1680 = DIRECTION('',(0.,0.,1.)); +#1681 = PCURVE('',#349,#1682); +#1682 = DEFINITIONAL_REPRESENTATION('',(#1683),#1687); +#1683 = LINE('',#1684,#1685); +#1684 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1685 = VECTOR('',#1686,1.); +#1686 = DIRECTION('',(-0.,-1.)); +#1687 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1688 = PCURVE('',#377,#1689); +#1689 = DEFINITIONAL_REPRESENTATION('',(#1690),#1694); +#1690 = LINE('',#1691,#1692); +#1691 = CARTESIAN_POINT('',(0.,-0.)); +#1692 = VECTOR('',#1693,1.); +#1693 = DIRECTION('',(0.,-1.)); +#1694 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1695 = ORIENTED_EDGE('',*,*,#328,.F.); +#1696 = ADVANCED_FACE('',(#1697),#780,.T.); +#1697 = FACE_BOUND('',#1698,.T.); +#1698 = EDGE_LOOP('',(#1699,#1720,#1721,#1722)); +#1699 = ORIENTED_EDGE('',*,*,#1700,.T.); +#1700 = EDGE_CURVE('',#732,#1349,#1701,.T.); +#1701 = SURFACE_CURVE('',#1702,(#1706,#1713),.PCURVE_S1.); +#1702 = LINE('',#1703,#1704); +#1703 = CARTESIAN_POINT('',(-23.,-37.6,0.)); +#1704 = VECTOR('',#1705,1.); +#1705 = DIRECTION('',(0.,0.,1.)); +#1706 = PCURVE('',#780,#1707); +#1707 = DEFINITIONAL_REPRESENTATION('',(#1708),#1712); +#1708 = LINE('',#1709,#1710); +#1709 = CARTESIAN_POINT('',(0.,0.)); +#1710 = VECTOR('',#1711,1.); +#1711 = DIRECTION('',(0.,-1.)); +#1712 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1713 = PCURVE('',#752,#1714); +#1714 = DEFINITIONAL_REPRESENTATION('',(#1715),#1719); +#1715 = LINE('',#1716,#1717); +#1716 = CARTESIAN_POINT('',(-1.570796325521,0.)); +#1717 = VECTOR('',#1718,1.); +#1718 = DIRECTION('',(-0.,-1.)); +#1719 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1720 = ORIENTED_EDGE('',*,*,#1376,.T.); +#1721 = ORIENTED_EDGE('',*,*,#1646,.F.); +#1722 = ORIENTED_EDGE('',*,*,#764,.F.); +#1723 = ADVANCED_FACE('',(#1724),#377,.T.); +#1724 = FACE_BOUND('',#1725,.T.); +#1725 = EDGE_LOOP('',(#1726,#1727,#1728,#1749)); +#1726 = ORIENTED_EDGE('',*,*,#1675,.T.); +#1727 = ORIENTED_EDGE('',*,*,#1043,.T.); +#1728 = ORIENTED_EDGE('',*,*,#1729,.F.); +#1729 = EDGE_CURVE('',#362,#1044,#1730,.T.); +#1730 = SURFACE_CURVE('',#1731,(#1735,#1742),.PCURVE_S1.); +#1731 = LINE('',#1732,#1733); +#1732 = CARTESIAN_POINT('',(-30.,38.6,0.)); +#1733 = VECTOR('',#1734,1.); +#1734 = DIRECTION('',(0.,0.,1.)); +#1735 = PCURVE('',#377,#1736); +#1736 = DEFINITIONAL_REPRESENTATION('',(#1737),#1741); +#1737 = LINE('',#1738,#1739); +#1738 = CARTESIAN_POINT('',(6.,0.)); +#1739 = VECTOR('',#1740,1.); +#1740 = DIRECTION('',(0.,-1.)); +#1741 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1742 = PCURVE('',#406,#1743); +#1743 = DEFINITIONAL_REPRESENTATION('',(#1744),#1748); +#1744 = LINE('',#1745,#1746); +#1745 = CARTESIAN_POINT('',(0.,0.)); +#1746 = VECTOR('',#1747,1.); +#1747 = DIRECTION('',(0.,-1.)); +#1748 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1749 = ORIENTED_EDGE('',*,*,#361,.F.); +#1750 = ADVANCED_FACE('',(#1751),#752,.F.); +#1751 = FACE_BOUND('',#1752,.T.); +#1752 = EDGE_LOOP('',(#1753,#1774,#1775,#1776)); +#1753 = ORIENTED_EDGE('',*,*,#1754,.T.); +#1754 = EDGE_CURVE('',#704,#1326,#1755,.T.); +#1755 = SURFACE_CURVE('',#1756,(#1760,#1767),.PCURVE_S1.); +#1756 = LINE('',#1757,#1758); +#1757 = CARTESIAN_POINT('',(-24.,-38.6,0.)); +#1758 = VECTOR('',#1759,1.); +#1759 = DIRECTION('',(0.,0.,1.)); +#1760 = PCURVE('',#752,#1761); +#1761 = DEFINITIONAL_REPRESENTATION('',(#1762),#1766); +#1762 = LINE('',#1763,#1764); +#1763 = CARTESIAN_POINT('',(-0.,0.)); +#1764 = VECTOR('',#1765,1.); +#1765 = DIRECTION('',(-0.,-1.)); +#1766 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1767 = PCURVE('',#719,#1768); +#1768 = DEFINITIONAL_REPRESENTATION('',(#1769),#1773); +#1769 = LINE('',#1770,#1771); +#1770 = CARTESIAN_POINT('',(6.,0.)); +#1771 = VECTOR('',#1772,1.); +#1772 = DIRECTION('',(0.,-1.)); +#1773 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1774 = ORIENTED_EDGE('',*,*,#1348,.T.); +#1775 = ORIENTED_EDGE('',*,*,#1700,.F.); +#1776 = ORIENTED_EDGE('',*,*,#731,.F.); +#1777 = ADVANCED_FACE('',(#1778),#406,.T.); +#1778 = FACE_BOUND('',#1779,.T.); +#1779 = EDGE_LOOP('',(#1780,#1781,#1782,#1803)); +#1780 = ORIENTED_EDGE('',*,*,#1729,.T.); +#1781 = ORIENTED_EDGE('',*,*,#1066,.T.); +#1782 = ORIENTED_EDGE('',*,*,#1783,.F.); +#1783 = EDGE_CURVE('',#390,#1067,#1784,.T.); +#1784 = SURFACE_CURVE('',#1785,(#1789,#1796),.PCURVE_S1.); +#1785 = LINE('',#1786,#1787); +#1786 = CARTESIAN_POINT('',(-33.,41.6,0.)); +#1787 = VECTOR('',#1788,1.); +#1788 = DIRECTION('',(0.,0.,1.)); +#1789 = PCURVE('',#406,#1790); +#1790 = DEFINITIONAL_REPRESENTATION('',(#1791),#1795); +#1791 = LINE('',#1792,#1793); +#1792 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1793 = VECTOR('',#1794,1.); +#1794 = DIRECTION('',(0.,-1.)); +#1795 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1796 = PCURVE('',#434,#1797); +#1797 = DEFINITIONAL_REPRESENTATION('',(#1798),#1802); +#1798 = LINE('',#1799,#1800); +#1799 = CARTESIAN_POINT('',(0.,0.)); +#1800 = VECTOR('',#1801,1.); +#1801 = DIRECTION('',(0.,-1.)); +#1802 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1803 = ORIENTED_EDGE('',*,*,#389,.F.); +#1804 = ADVANCED_FACE('',(#1805),#719,.T.); +#1805 = FACE_BOUND('',#1806,.T.); +#1806 = EDGE_LOOP('',(#1807,#1828,#1829,#1830)); +#1807 = ORIENTED_EDGE('',*,*,#1808,.T.); +#1808 = EDGE_CURVE('',#675,#1302,#1809,.T.); +#1809 = SURFACE_CURVE('',#1810,(#1814,#1821),.PCURVE_S1.); +#1810 = LINE('',#1811,#1812); +#1811 = CARTESIAN_POINT('',(-30.,-38.6,0.)); +#1812 = VECTOR('',#1813,1.); +#1813 = DIRECTION('',(0.,0.,1.)); +#1814 = PCURVE('',#719,#1815); +#1815 = DEFINITIONAL_REPRESENTATION('',(#1816),#1820); +#1816 = LINE('',#1817,#1818); +#1817 = CARTESIAN_POINT('',(0.,0.)); +#1818 = VECTOR('',#1819,1.); +#1819 = DIRECTION('',(0.,-1.)); +#1820 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1821 = PCURVE('',#691,#1822); +#1822 = DEFINITIONAL_REPRESENTATION('',(#1823),#1827); +#1823 = LINE('',#1824,#1825); +#1824 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1825 = VECTOR('',#1826,1.); +#1826 = DIRECTION('',(0.,-1.)); +#1827 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1828 = ORIENTED_EDGE('',*,*,#1325,.T.); +#1829 = ORIENTED_EDGE('',*,*,#1754,.F.); +#1830 = ORIENTED_EDGE('',*,*,#703,.F.); +#1831 = ADVANCED_FACE('',(#1832),#434,.T.); +#1832 = FACE_BOUND('',#1833,.T.); +#1833 = EDGE_LOOP('',(#1834,#1835,#1836,#1857)); +#1834 = ORIENTED_EDGE('',*,*,#1783,.T.); +#1835 = ORIENTED_EDGE('',*,*,#1090,.T.); +#1836 = ORIENTED_EDGE('',*,*,#1837,.F.); +#1837 = EDGE_CURVE('',#419,#1091,#1838,.T.); +#1838 = SURFACE_CURVE('',#1839,(#1843,#1850),.PCURVE_S1.); +#1839 = LINE('',#1840,#1841); +#1840 = CARTESIAN_POINT('',(-33.,61.6,0.)); +#1841 = VECTOR('',#1842,1.); +#1842 = DIRECTION('',(0.,0.,1.)); +#1843 = PCURVE('',#434,#1844); +#1844 = DEFINITIONAL_REPRESENTATION('',(#1845),#1849); +#1845 = LINE('',#1846,#1847); +#1846 = CARTESIAN_POINT('',(20.,0.)); +#1847 = VECTOR('',#1848,1.); +#1848 = DIRECTION('',(0.,-1.)); +#1849 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1850 = PCURVE('',#463,#1851); +#1851 = DEFINITIONAL_REPRESENTATION('',(#1852),#1856); +#1852 = LINE('',#1853,#1854); +#1853 = CARTESIAN_POINT('',(0.,0.)); +#1854 = VECTOR('',#1855,1.); +#1855 = DIRECTION('',(0.,-1.)); +#1856 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1857 = ORIENTED_EDGE('',*,*,#418,.F.); +#1858 = ADVANCED_FACE('',(#1859),#691,.T.); +#1859 = FACE_BOUND('',#1860,.T.); +#1860 = EDGE_LOOP('',(#1861,#1882,#1883,#1884)); +#1861 = ORIENTED_EDGE('',*,*,#1862,.T.); +#1862 = EDGE_CURVE('',#647,#1279,#1863,.T.); +#1863 = SURFACE_CURVE('',#1864,(#1868,#1875),.PCURVE_S1.); +#1864 = LINE('',#1865,#1866); +#1865 = CARTESIAN_POINT('',(-33.,-41.6,0.)); +#1866 = VECTOR('',#1867,1.); +#1867 = DIRECTION('',(0.,0.,1.)); +#1868 = PCURVE('',#691,#1869); +#1869 = DEFINITIONAL_REPRESENTATION('',(#1870),#1874); +#1870 = LINE('',#1871,#1872); +#1871 = CARTESIAN_POINT('',(0.,0.)); +#1872 = VECTOR('',#1873,1.); +#1873 = DIRECTION('',(0.,-1.)); +#1874 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1875 = PCURVE('',#662,#1876); +#1876 = DEFINITIONAL_REPRESENTATION('',(#1877),#1881); +#1877 = LINE('',#1878,#1879); +#1878 = CARTESIAN_POINT('',(20.,0.)); +#1879 = VECTOR('',#1880,1.); +#1880 = DIRECTION('',(0.,-1.)); +#1881 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1882 = ORIENTED_EDGE('',*,*,#1301,.T.); +#1883 = ORIENTED_EDGE('',*,*,#1808,.F.); +#1884 = ORIENTED_EDGE('',*,*,#674,.F.); +#1885 = ADVANCED_FACE('',(#1886),#463,.T.); +#1886 = FACE_BOUND('',#1887,.T.); +#1887 = EDGE_LOOP('',(#1888,#1889,#1890,#1911)); +#1888 = ORIENTED_EDGE('',*,*,#1837,.T.); +#1889 = ORIENTED_EDGE('',*,*,#1113,.T.); +#1890 = ORIENTED_EDGE('',*,*,#1891,.F.); +#1891 = EDGE_CURVE('',#447,#1114,#1892,.T.); +#1892 = SURFACE_CURVE('',#1893,(#1897,#1904),.PCURVE_S1.); +#1893 = LINE('',#1894,#1895); +#1894 = CARTESIAN_POINT('',(-30.,64.6,0.)); +#1895 = VECTOR('',#1896,1.); +#1896 = DIRECTION('',(0.,0.,1.)); +#1897 = PCURVE('',#463,#1898); +#1898 = DEFINITIONAL_REPRESENTATION('',(#1899),#1903); +#1899 = LINE('',#1900,#1901); +#1900 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1901 = VECTOR('',#1902,1.); +#1902 = DIRECTION('',(0.,-1.)); +#1903 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1904 = PCURVE('',#491,#1905); +#1905 = DEFINITIONAL_REPRESENTATION('',(#1906),#1910); +#1906 = LINE('',#1907,#1908); +#1907 = CARTESIAN_POINT('',(0.,0.)); +#1908 = VECTOR('',#1909,1.); +#1909 = DIRECTION('',(0.,-1.)); +#1910 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1911 = ORIENTED_EDGE('',*,*,#446,.F.); +#1912 = ADVANCED_FACE('',(#1913),#662,.T.); +#1913 = FACE_BOUND('',#1914,.T.); +#1914 = EDGE_LOOP('',(#1915,#1936,#1937,#1938)); +#1915 = ORIENTED_EDGE('',*,*,#1916,.T.); +#1916 = EDGE_CURVE('',#618,#1255,#1917,.T.); +#1917 = SURFACE_CURVE('',#1918,(#1922,#1929),.PCURVE_S1.); +#1918 = LINE('',#1919,#1920); +#1919 = CARTESIAN_POINT('',(-33.,-61.6,0.)); +#1920 = VECTOR('',#1921,1.); +#1921 = DIRECTION('',(0.,0.,1.)); +#1922 = PCURVE('',#662,#1923); +#1923 = DEFINITIONAL_REPRESENTATION('',(#1924),#1928); +#1924 = LINE('',#1925,#1926); +#1925 = CARTESIAN_POINT('',(0.,0.)); +#1926 = VECTOR('',#1927,1.); +#1927 = DIRECTION('',(0.,-1.)); +#1928 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1929 = PCURVE('',#634,#1930); +#1930 = DEFINITIONAL_REPRESENTATION('',(#1931),#1935); +#1931 = LINE('',#1932,#1933); +#1932 = CARTESIAN_POINT('',(1.570796327797,0.)); +#1933 = VECTOR('',#1934,1.); +#1934 = DIRECTION('',(0.,-1.)); +#1935 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1936 = ORIENTED_EDGE('',*,*,#1278,.T.); +#1937 = ORIENTED_EDGE('',*,*,#1862,.F.); +#1938 = ORIENTED_EDGE('',*,*,#646,.F.); +#1939 = ADVANCED_FACE('',(#1940),#491,.T.); +#1940 = FACE_BOUND('',#1941,.T.); +#1941 = EDGE_LOOP('',(#1942,#1943,#1944,#1965)); +#1942 = ORIENTED_EDGE('',*,*,#1891,.T.); +#1943 = ORIENTED_EDGE('',*,*,#1137,.T.); +#1944 = ORIENTED_EDGE('',*,*,#1945,.F.); +#1945 = EDGE_CURVE('',#476,#1138,#1946,.T.); +#1946 = SURFACE_CURVE('',#1947,(#1951,#1958),.PCURVE_S1.); +#1947 = LINE('',#1948,#1949); +#1948 = CARTESIAN_POINT('',(26.,64.6,0.)); +#1949 = VECTOR('',#1950,1.); +#1950 = DIRECTION('',(0.,0.,1.)); +#1951 = PCURVE('',#491,#1952); +#1952 = DEFINITIONAL_REPRESENTATION('',(#1953),#1957); +#1953 = LINE('',#1954,#1955); +#1954 = CARTESIAN_POINT('',(56.,0.)); +#1955 = VECTOR('',#1956,1.); +#1956 = DIRECTION('',(0.,-1.)); +#1957 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1958 = PCURVE('',#520,#1959); +#1959 = DEFINITIONAL_REPRESENTATION('',(#1960),#1964); +#1960 = LINE('',#1961,#1962); +#1961 = CARTESIAN_POINT('',(0.,0.)); +#1962 = VECTOR('',#1963,1.); +#1963 = DIRECTION('',(0.,-1.)); +#1964 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1965 = ORIENTED_EDGE('',*,*,#475,.F.); +#1966 = ADVANCED_FACE('',(#1967),#634,.T.); +#1967 = FACE_BOUND('',#1968,.T.); +#1968 = EDGE_LOOP('',(#1969,#1990,#1991,#1992)); +#1969 = ORIENTED_EDGE('',*,*,#1970,.T.); +#1970 = EDGE_CURVE('',#590,#1232,#1971,.T.); +#1971 = SURFACE_CURVE('',#1972,(#1976,#1983),.PCURVE_S1.); +#1972 = LINE('',#1973,#1974); +#1973 = CARTESIAN_POINT('',(-30.,-64.6,0.)); +#1974 = VECTOR('',#1975,1.); +#1975 = DIRECTION('',(0.,0.,1.)); +#1976 = PCURVE('',#634,#1977); +#1977 = DEFINITIONAL_REPRESENTATION('',(#1978),#1982); +#1978 = LINE('',#1979,#1980); +#1979 = CARTESIAN_POINT('',(0.,0.)); +#1980 = VECTOR('',#1981,1.); +#1981 = DIRECTION('',(0.,-1.)); +#1982 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1983 = PCURVE('',#605,#1984); +#1984 = DEFINITIONAL_REPRESENTATION('',(#1985),#1989); +#1985 = LINE('',#1986,#1987); +#1986 = CARTESIAN_POINT('',(56.,0.)); +#1987 = VECTOR('',#1988,1.); +#1988 = DIRECTION('',(0.,-1.)); +#1989 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#1990 = ORIENTED_EDGE('',*,*,#1254,.T.); +#1991 = ORIENTED_EDGE('',*,*,#1916,.F.); +#1992 = ORIENTED_EDGE('',*,*,#617,.F.); +#1993 = ADVANCED_FACE('',(#1994),#520,.T.); +#1994 = FACE_BOUND('',#1995,.T.); +#1995 = EDGE_LOOP('',(#1996,#1997,#1998,#2019)); +#1996 = ORIENTED_EDGE('',*,*,#1945,.T.); +#1997 = ORIENTED_EDGE('',*,*,#1160,.T.); +#1998 = ORIENTED_EDGE('',*,*,#1999,.F.); +#1999 = EDGE_CURVE('',#504,#1161,#2000,.T.); +#2000 = SURFACE_CURVE('',#2001,(#2005,#2012),.PCURVE_S1.); +#2001 = LINE('',#2002,#2003); +#2002 = CARTESIAN_POINT('',(29.,61.6,0.)); +#2003 = VECTOR('',#2004,1.); +#2004 = DIRECTION('',(0.,0.,1.)); +#2005 = PCURVE('',#520,#2006); +#2006 = DEFINITIONAL_REPRESENTATION('',(#2007),#2011); +#2007 = LINE('',#2008,#2009); +#2008 = CARTESIAN_POINT('',(1.570796327797,0.)); +#2009 = VECTOR('',#2010,1.); +#2010 = DIRECTION('',(0.,-1.)); +#2011 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2012 = PCURVE('',#548,#2013); +#2013 = DEFINITIONAL_REPRESENTATION('',(#2014),#2018); +#2014 = LINE('',#2015,#2016); +#2015 = CARTESIAN_POINT('',(0.,0.)); +#2016 = VECTOR('',#2017,1.); +#2017 = DIRECTION('',(0.,-1.)); +#2018 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2019 = ORIENTED_EDGE('',*,*,#503,.F.); +#2020 = ADVANCED_FACE('',(#2021),#605,.T.); +#2021 = FACE_BOUND('',#2022,.T.); +#2022 = EDGE_LOOP('',(#2023,#2044,#2045,#2046)); +#2023 = ORIENTED_EDGE('',*,*,#2024,.T.); +#2024 = EDGE_CURVE('',#561,#1208,#2025,.T.); +#2025 = SURFACE_CURVE('',#2026,(#2030,#2037),.PCURVE_S1.); +#2026 = LINE('',#2027,#2028); +#2027 = CARTESIAN_POINT('',(26.,-64.6,0.)); +#2028 = VECTOR('',#2029,1.); +#2029 = DIRECTION('',(0.,0.,1.)); +#2030 = PCURVE('',#605,#2031); +#2031 = DEFINITIONAL_REPRESENTATION('',(#2032),#2036); +#2032 = LINE('',#2033,#2034); +#2033 = CARTESIAN_POINT('',(0.,-0.)); +#2034 = VECTOR('',#2035,1.); +#2035 = DIRECTION('',(0.,-1.)); +#2036 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2037 = PCURVE('',#577,#2038); +#2038 = DEFINITIONAL_REPRESENTATION('',(#2039),#2043); +#2039 = LINE('',#2040,#2041); +#2040 = CARTESIAN_POINT('',(1.570796326659,0.)); +#2041 = VECTOR('',#2042,1.); +#2042 = DIRECTION('',(0.,-1.)); +#2043 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2044 = ORIENTED_EDGE('',*,*,#1231,.T.); +#2045 = ORIENTED_EDGE('',*,*,#1970,.F.); +#2046 = ORIENTED_EDGE('',*,*,#589,.F.); +#2047 = ADVANCED_FACE('',(#2048),#548,.T.); +#2048 = FACE_BOUND('',#2049,.T.); +#2049 = EDGE_LOOP('',(#2050,#2051,#2052,#2073)); +#2050 = ORIENTED_EDGE('',*,*,#1999,.T.); +#2051 = ORIENTED_EDGE('',*,*,#1184,.T.); +#2052 = ORIENTED_EDGE('',*,*,#2053,.F.); +#2053 = EDGE_CURVE('',#533,#1185,#2054,.T.); +#2054 = SURFACE_CURVE('',#2055,(#2059,#2066),.PCURVE_S1.); +#2055 = LINE('',#2056,#2057); +#2056 = CARTESIAN_POINT('',(29.,-61.6,0.)); +#2057 = VECTOR('',#2058,1.); +#2058 = DIRECTION('',(0.,0.,1.)); +#2059 = PCURVE('',#548,#2060); +#2060 = DEFINITIONAL_REPRESENTATION('',(#2061),#2065); +#2061 = LINE('',#2062,#2063); +#2062 = CARTESIAN_POINT('',(123.2,0.)); +#2063 = VECTOR('',#2064,1.); +#2064 = DIRECTION('',(0.,-1.)); +#2065 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2066 = PCURVE('',#577,#2067); +#2067 = DEFINITIONAL_REPRESENTATION('',(#2068),#2072); +#2068 = LINE('',#2069,#2070); +#2069 = CARTESIAN_POINT('',(0.,0.)); +#2070 = VECTOR('',#2071,1.); +#2071 = DIRECTION('',(0.,-1.)); +#2072 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2073 = ORIENTED_EDGE('',*,*,#532,.F.); +#2074 = ADVANCED_FACE('',(#2075),#577,.T.); +#2075 = FACE_BOUND('',#2076,.T.); +#2076 = EDGE_LOOP('',(#2077,#2078,#2079,#2080)); +#2077 = ORIENTED_EDGE('',*,*,#2053,.T.); +#2078 = ORIENTED_EDGE('',*,*,#1207,.T.); +#2079 = ORIENTED_EDGE('',*,*,#2024,.F.); +#2080 = ORIENTED_EDGE('',*,*,#560,.F.); +#2081 = ADVANCED_FACE('',(#2082),#870,.F.); +#2082 = FACE_BOUND('',#2083,.T.); +#2083 = EDGE_LOOP('',(#2084,#2107,#2134,#2135)); +#2084 = ORIENTED_EDGE('',*,*,#2085,.T.); +#2085 = EDGE_CURVE('',#850,#2086,#2088,.T.); +#2086 = VERTEX_POINT('',#2087); +#2087 = CARTESIAN_POINT('',(28.15,-61.6,2.3)); +#2088 = SEAM_CURVE('',#2089,(#2093,#2100),.PCURVE_S1.); +#2089 = LINE('',#2090,#2091); +#2090 = CARTESIAN_POINT('',(28.15,-61.6,0.)); +#2091 = VECTOR('',#2092,1.); +#2092 = DIRECTION('',(0.,0.,1.)); +#2093 = PCURVE('',#870,#2094); +#2094 = DEFINITIONAL_REPRESENTATION('',(#2095),#2099); +#2095 = LINE('',#2096,#2097); +#2096 = CARTESIAN_POINT('',(-0.,0.)); +#2097 = VECTOR('',#2098,1.); +#2098 = DIRECTION('',(-0.,-1.)); +#2099 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2100 = PCURVE('',#870,#2101); +#2101 = DEFINITIONAL_REPRESENTATION('',(#2102),#2106); +#2102 = LINE('',#2103,#2104); +#2103 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2104 = VECTOR('',#2105,1.); +#2105 = DIRECTION('',(-0.,-1.)); +#2106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2107 = ORIENTED_EDGE('',*,*,#2108,.T.); +#2108 = EDGE_CURVE('',#2086,#2086,#2109,.T.); +#2109 = SURFACE_CURVE('',#2110,(#2115,#2122),.PCURVE_S1.); +#2110 = CIRCLE('',#2111,2.15); +#2111 = AXIS2_PLACEMENT_3D('',#2112,#2113,#2114); +#2112 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2113 = DIRECTION('',(0.,0.,1.)); +#2114 = DIRECTION('',(1.,0.,0.)); +#2115 = PCURVE('',#870,#2116); +#2116 = DEFINITIONAL_REPRESENTATION('',(#2117),#2121); +#2117 = LINE('',#2118,#2119); +#2118 = CARTESIAN_POINT('',(-0.,-2.3)); +#2119 = VECTOR('',#2120,1.); +#2120 = DIRECTION('',(-1.,0.)); +#2121 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2122 = PCURVE('',#2123,#2128); +#2123 = PLANE('',#2124); +#2124 = AXIS2_PLACEMENT_3D('',#2125,#2126,#2127); +#2125 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2126 = DIRECTION('',(0.,0.,1.)); +#2127 = DIRECTION('',(1.,0.,-0.)); +#2128 = DEFINITIONAL_REPRESENTATION('',(#2129),#2133); +#2129 = CIRCLE('',#2130,2.15); +#2130 = AXIS2_PLACEMENT_2D('',#2131,#2132); +#2131 = CARTESIAN_POINT('',(0.,-7.105427357601E-15)); +#2132 = DIRECTION('',(1.,0.)); +#2133 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2134 = ORIENTED_EDGE('',*,*,#2085,.F.); +#2135 = ORIENTED_EDGE('',*,*,#849,.F.); +#2136 = ADVANCED_FACE('',(#2137),#905,.F.); +#2137 = FACE_BOUND('',#2138,.T.); +#2138 = EDGE_LOOP('',(#2139,#2162,#2189,#2190)); +#2139 = ORIENTED_EDGE('',*,*,#2140,.T.); +#2140 = EDGE_CURVE('',#885,#2141,#2143,.T.); +#2141 = VERTEX_POINT('',#2142); +#2142 = CARTESIAN_POINT('',(-27.85,-61.6,2.3)); +#2143 = SEAM_CURVE('',#2144,(#2148,#2155),.PCURVE_S1.); +#2144 = LINE('',#2145,#2146); +#2145 = CARTESIAN_POINT('',(-27.85,-61.6,0.)); +#2146 = VECTOR('',#2147,1.); +#2147 = DIRECTION('',(0.,0.,1.)); +#2148 = PCURVE('',#905,#2149); +#2149 = DEFINITIONAL_REPRESENTATION('',(#2150),#2154); +#2150 = LINE('',#2151,#2152); +#2151 = CARTESIAN_POINT('',(-0.,0.)); +#2152 = VECTOR('',#2153,1.); +#2153 = DIRECTION('',(-0.,-1.)); +#2154 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2155 = PCURVE('',#905,#2156); +#2156 = DEFINITIONAL_REPRESENTATION('',(#2157),#2161); +#2157 = LINE('',#2158,#2159); +#2158 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2159 = VECTOR('',#2160,1.); +#2160 = DIRECTION('',(-0.,-1.)); +#2161 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2162 = ORIENTED_EDGE('',*,*,#2163,.T.); +#2163 = EDGE_CURVE('',#2141,#2141,#2164,.T.); +#2164 = SURFACE_CURVE('',#2165,(#2170,#2177),.PCURVE_S1.); +#2165 = CIRCLE('',#2166,2.15); +#2166 = AXIS2_PLACEMENT_3D('',#2167,#2168,#2169); +#2167 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2168 = DIRECTION('',(0.,0.,1.)); +#2169 = DIRECTION('',(1.,0.,0.)); +#2170 = PCURVE('',#905,#2171); +#2171 = DEFINITIONAL_REPRESENTATION('',(#2172),#2176); +#2172 = LINE('',#2173,#2174); +#2173 = CARTESIAN_POINT('',(-0.,-2.3)); +#2174 = VECTOR('',#2175,1.); +#2175 = DIRECTION('',(-1.,0.)); +#2176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2177 = PCURVE('',#2178,#2183); +#2178 = PLANE('',#2179); +#2179 = AXIS2_PLACEMENT_3D('',#2180,#2181,#2182); +#2180 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2181 = DIRECTION('',(0.,0.,1.)); +#2182 = DIRECTION('',(1.,0.,-0.)); +#2183 = DEFINITIONAL_REPRESENTATION('',(#2184),#2188); +#2184 = CIRCLE('',#2185,2.15); +#2185 = AXIS2_PLACEMENT_2D('',#2186,#2187); +#2186 = CARTESIAN_POINT('',(-3.552713678801E-15,-7.105427357601E-15)); +#2187 = DIRECTION('',(1.,0.)); +#2188 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2189 = ORIENTED_EDGE('',*,*,#2140,.F.); +#2190 = ORIENTED_EDGE('',*,*,#884,.F.); +#2191 = ADVANCED_FACE('',(#2192),#940,.F.); +#2192 = FACE_BOUND('',#2193,.T.); +#2193 = EDGE_LOOP('',(#2194,#2217,#2244,#2245)); +#2194 = ORIENTED_EDGE('',*,*,#2195,.T.); +#2195 = EDGE_CURVE('',#920,#2196,#2198,.T.); +#2196 = VERTEX_POINT('',#2197); +#2197 = CARTESIAN_POINT('',(28.15,61.6,2.3)); +#2198 = SEAM_CURVE('',#2199,(#2203,#2210),.PCURVE_S1.); +#2199 = LINE('',#2200,#2201); +#2200 = CARTESIAN_POINT('',(28.15,61.6,0.)); +#2201 = VECTOR('',#2202,1.); +#2202 = DIRECTION('',(0.,0.,1.)); +#2203 = PCURVE('',#940,#2204); +#2204 = DEFINITIONAL_REPRESENTATION('',(#2205),#2209); +#2205 = LINE('',#2206,#2207); +#2206 = CARTESIAN_POINT('',(-0.,0.)); +#2207 = VECTOR('',#2208,1.); +#2208 = DIRECTION('',(-0.,-1.)); +#2209 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2210 = PCURVE('',#940,#2211); +#2211 = DEFINITIONAL_REPRESENTATION('',(#2212),#2216); +#2212 = LINE('',#2213,#2214); +#2213 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2214 = VECTOR('',#2215,1.); +#2215 = DIRECTION('',(-0.,-1.)); +#2216 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2217 = ORIENTED_EDGE('',*,*,#2218,.T.); +#2218 = EDGE_CURVE('',#2196,#2196,#2219,.T.); +#2219 = SURFACE_CURVE('',#2220,(#2225,#2232),.PCURVE_S1.); +#2220 = CIRCLE('',#2221,2.15); +#2221 = AXIS2_PLACEMENT_3D('',#2222,#2223,#2224); +#2222 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2223 = DIRECTION('',(0.,0.,1.)); +#2224 = DIRECTION('',(1.,0.,0.)); +#2225 = PCURVE('',#940,#2226); +#2226 = DEFINITIONAL_REPRESENTATION('',(#2227),#2231); +#2227 = LINE('',#2228,#2229); +#2228 = CARTESIAN_POINT('',(-0.,-2.3)); +#2229 = VECTOR('',#2230,1.); +#2230 = DIRECTION('',(-1.,0.)); +#2231 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2232 = PCURVE('',#2233,#2238); +#2233 = PLANE('',#2234); +#2234 = AXIS2_PLACEMENT_3D('',#2235,#2236,#2237); +#2235 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2236 = DIRECTION('',(0.,0.,1.)); +#2237 = DIRECTION('',(1.,0.,-0.)); +#2238 = DEFINITIONAL_REPRESENTATION('',(#2239),#2243); +#2239 = CIRCLE('',#2240,2.15); +#2240 = AXIS2_PLACEMENT_2D('',#2241,#2242); +#2241 = CARTESIAN_POINT('',(0.,7.105427357601E-15)); +#2242 = DIRECTION('',(1.,0.)); +#2243 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2244 = ORIENTED_EDGE('',*,*,#2195,.F.); +#2245 = ORIENTED_EDGE('',*,*,#919,.F.); +#2246 = ADVANCED_FACE('',(#2247),#975,.F.); +#2247 = FACE_BOUND('',#2248,.T.); +#2248 = EDGE_LOOP('',(#2249,#2272,#2299,#2300)); +#2249 = ORIENTED_EDGE('',*,*,#2250,.T.); +#2250 = EDGE_CURVE('',#955,#2251,#2253,.T.); +#2251 = VERTEX_POINT('',#2252); +#2252 = CARTESIAN_POINT('',(-27.85,61.6,2.3)); +#2253 = SEAM_CURVE('',#2254,(#2258,#2265),.PCURVE_S1.); +#2254 = LINE('',#2255,#2256); +#2255 = CARTESIAN_POINT('',(-27.85,61.6,0.)); +#2256 = VECTOR('',#2257,1.); +#2257 = DIRECTION('',(0.,0.,1.)); +#2258 = PCURVE('',#975,#2259); +#2259 = DEFINITIONAL_REPRESENTATION('',(#2260),#2264); +#2260 = LINE('',#2261,#2262); +#2261 = CARTESIAN_POINT('',(-0.,0.)); +#2262 = VECTOR('',#2263,1.); +#2263 = DIRECTION('',(-0.,-1.)); +#2264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2265 = PCURVE('',#975,#2266); +#2266 = DEFINITIONAL_REPRESENTATION('',(#2267),#2271); +#2267 = LINE('',#2268,#2269); +#2268 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2269 = VECTOR('',#2270,1.); +#2270 = DIRECTION('',(-0.,-1.)); +#2271 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2272 = ORIENTED_EDGE('',*,*,#2273,.T.); +#2273 = EDGE_CURVE('',#2251,#2251,#2274,.T.); +#2274 = SURFACE_CURVE('',#2275,(#2280,#2287),.PCURVE_S1.); +#2275 = CIRCLE('',#2276,2.15); +#2276 = AXIS2_PLACEMENT_3D('',#2277,#2278,#2279); +#2277 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2278 = DIRECTION('',(0.,0.,1.)); +#2279 = DIRECTION('',(1.,0.,0.)); +#2280 = PCURVE('',#975,#2281); +#2281 = DEFINITIONAL_REPRESENTATION('',(#2282),#2286); +#2282 = LINE('',#2283,#2284); +#2283 = CARTESIAN_POINT('',(-0.,-2.3)); +#2284 = VECTOR('',#2285,1.); +#2285 = DIRECTION('',(-1.,0.)); +#2286 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2287 = PCURVE('',#2288,#2293); +#2288 = PLANE('',#2289); +#2289 = AXIS2_PLACEMENT_3D('',#2290,#2291,#2292); +#2290 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2291 = DIRECTION('',(0.,0.,1.)); +#2292 = DIRECTION('',(1.,0.,-0.)); +#2293 = DEFINITIONAL_REPRESENTATION('',(#2294),#2298); +#2294 = CIRCLE('',#2295,2.15); +#2295 = AXIS2_PLACEMENT_2D('',#2296,#2297); +#2296 = CARTESIAN_POINT('',(-3.552713678801E-15,7.105427357601E-15)); +#2297 = DIRECTION('',(1.,0.)); +#2298 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2299 = ORIENTED_EDGE('',*,*,#2250,.F.); +#2300 = ORIENTED_EDGE('',*,*,#954,.F.); +#2301 = ADVANCED_FACE('',(#2302),#1472,.F.); +#2302 = FACE_BOUND('',#2303,.T.); +#2303 = EDGE_LOOP('',(#2304,#2332,#2353,#2354)); +#2304 = ORIENTED_EDGE('',*,*,#2305,.T.); +#2305 = EDGE_CURVE('',#2306,#2306,#2308,.T.); +#2306 = VERTEX_POINT('',#2307); +#2307 = CARTESIAN_POINT('',(27.15,-61.6,2.3)); +#2308 = SURFACE_CURVE('',#2309,(#2314,#2321),.PCURVE_S1.); +#2309 = CIRCLE('',#2310,1.15); +#2310 = AXIS2_PLACEMENT_3D('',#2311,#2312,#2313); +#2311 = CARTESIAN_POINT('',(26.,-61.6,2.3)); +#2312 = DIRECTION('',(0.,0.,-1.)); +#2313 = DIRECTION('',(1.,0.,0.)); +#2314 = PCURVE('',#1472,#2315); +#2315 = DEFINITIONAL_REPRESENTATION('',(#2316),#2320); +#2316 = LINE('',#2317,#2318); +#2317 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2318 = VECTOR('',#2319,1.); +#2319 = DIRECTION('',(1.,-0.)); +#2320 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2321 = PCURVE('',#2123,#2322); +#2322 = DEFINITIONAL_REPRESENTATION('',(#2323),#2331); +#2323 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2324,#2325,#2326,#2327, +#2328,#2329,#2330),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2324 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2325 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2326 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2327 = CARTESIAN_POINT('',(-2.3,-7.387096121405E-15)); +#2328 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2329 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2330 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2331 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2332 = ORIENTED_EDGE('',*,*,#2333,.T.); +#2333 = EDGE_CURVE('',#2306,#1452,#2334,.T.); +#2334 = SEAM_CURVE('',#2335,(#2339,#2346),.PCURVE_S1.); +#2335 = LINE('',#2336,#2337); +#2336 = CARTESIAN_POINT('',(27.15,-61.6,0.)); +#2337 = VECTOR('',#2338,1.); +#2338 = DIRECTION('',(0.,0.,1.)); +#2339 = PCURVE('',#1472,#2340); +#2340 = DEFINITIONAL_REPRESENTATION('',(#2341),#2345); +#2341 = LINE('',#2342,#2343); +#2342 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2343 = VECTOR('',#2344,1.); +#2344 = DIRECTION('',(-0.,-1.)); +#2345 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2346 = PCURVE('',#1472,#2347); +#2347 = DEFINITIONAL_REPRESENTATION('',(#2348),#2352); +#2348 = LINE('',#2349,#2350); +#2349 = CARTESIAN_POINT('',(-0.,0.)); +#2350 = VECTOR('',#2351,1.); +#2351 = DIRECTION('',(-0.,-1.)); +#2352 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2353 = ORIENTED_EDGE('',*,*,#1451,.T.); +#2354 = ORIENTED_EDGE('',*,*,#2333,.F.); +#2355 = ADVANCED_FACE('',(#2356),#1507,.F.); +#2356 = FACE_BOUND('',#2357,.T.); +#2357 = EDGE_LOOP('',(#2358,#2386,#2407,#2408)); +#2358 = ORIENTED_EDGE('',*,*,#2359,.T.); +#2359 = EDGE_CURVE('',#2360,#2360,#2362,.T.); +#2360 = VERTEX_POINT('',#2361); +#2361 = CARTESIAN_POINT('',(-28.85,-61.6,2.3)); +#2362 = SURFACE_CURVE('',#2363,(#2368,#2375),.PCURVE_S1.); +#2363 = CIRCLE('',#2364,1.15); +#2364 = AXIS2_PLACEMENT_3D('',#2365,#2366,#2367); +#2365 = CARTESIAN_POINT('',(-30.,-61.6,2.3)); +#2366 = DIRECTION('',(0.,0.,-1.)); +#2367 = DIRECTION('',(1.,0.,0.)); +#2368 = PCURVE('',#1507,#2369); +#2369 = DEFINITIONAL_REPRESENTATION('',(#2370),#2374); +#2370 = LINE('',#2371,#2372); +#2371 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2372 = VECTOR('',#2373,1.); +#2373 = DIRECTION('',(1.,-0.)); +#2374 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2375 = PCURVE('',#2178,#2376); +#2376 = DEFINITIONAL_REPRESENTATION('',(#2377),#2385); +#2377 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2378,#2379,#2380,#2381, +#2382,#2383,#2384),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2378 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2379 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2380 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2381 = CARTESIAN_POINT('',(-2.3,-7.387096121405E-15)); +#2382 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2383 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2384 = CARTESIAN_POINT('',(1.15,-7.105427357601E-15)); +#2385 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2386 = ORIENTED_EDGE('',*,*,#2387,.T.); +#2387 = EDGE_CURVE('',#2360,#1487,#2388,.T.); +#2388 = SEAM_CURVE('',#2389,(#2393,#2400),.PCURVE_S1.); +#2389 = LINE('',#2390,#2391); +#2390 = CARTESIAN_POINT('',(-28.85,-61.6,0.)); +#2391 = VECTOR('',#2392,1.); +#2392 = DIRECTION('',(0.,0.,1.)); +#2393 = PCURVE('',#1507,#2394); +#2394 = DEFINITIONAL_REPRESENTATION('',(#2395),#2399); +#2395 = LINE('',#2396,#2397); +#2396 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2397 = VECTOR('',#2398,1.); +#2398 = DIRECTION('',(-0.,-1.)); +#2399 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2400 = PCURVE('',#1507,#2401); +#2401 = DEFINITIONAL_REPRESENTATION('',(#2402),#2406); +#2402 = LINE('',#2403,#2404); +#2403 = CARTESIAN_POINT('',(-0.,0.)); +#2404 = VECTOR('',#2405,1.); +#2405 = DIRECTION('',(-0.,-1.)); +#2406 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2407 = ORIENTED_EDGE('',*,*,#1486,.T.); +#2408 = ORIENTED_EDGE('',*,*,#2387,.F.); +#2409 = ADVANCED_FACE('',(#2410),#1542,.F.); +#2410 = FACE_BOUND('',#2411,.T.); +#2411 = EDGE_LOOP('',(#2412,#2440,#2461,#2462)); +#2412 = ORIENTED_EDGE('',*,*,#2413,.T.); +#2413 = EDGE_CURVE('',#2414,#2414,#2416,.T.); +#2414 = VERTEX_POINT('',#2415); +#2415 = CARTESIAN_POINT('',(27.15,61.6,2.3)); +#2416 = SURFACE_CURVE('',#2417,(#2422,#2429),.PCURVE_S1.); +#2417 = CIRCLE('',#2418,1.15); +#2418 = AXIS2_PLACEMENT_3D('',#2419,#2420,#2421); +#2419 = CARTESIAN_POINT('',(26.,61.6,2.3)); +#2420 = DIRECTION('',(0.,0.,-1.)); +#2421 = DIRECTION('',(1.,0.,0.)); +#2422 = PCURVE('',#1542,#2423); +#2423 = DEFINITIONAL_REPRESENTATION('',(#2424),#2428); +#2424 = LINE('',#2425,#2426); +#2425 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2426 = VECTOR('',#2427,1.); +#2427 = DIRECTION('',(1.,-0.)); +#2428 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2429 = PCURVE('',#2233,#2430); +#2430 = DEFINITIONAL_REPRESENTATION('',(#2431),#2439); +#2431 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2432,#2433,#2434,#2435, +#2436,#2437,#2438),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2432 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2433 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2434 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2435 = CARTESIAN_POINT('',(-2.3,6.823758593797E-15)); +#2436 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2437 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2438 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2439 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2440 = ORIENTED_EDGE('',*,*,#2441,.T.); +#2441 = EDGE_CURVE('',#2414,#1522,#2442,.T.); +#2442 = SEAM_CURVE('',#2443,(#2447,#2454),.PCURVE_S1.); +#2443 = LINE('',#2444,#2445); +#2444 = CARTESIAN_POINT('',(27.15,61.6,0.)); +#2445 = VECTOR('',#2446,1.); +#2446 = DIRECTION('',(0.,0.,1.)); +#2447 = PCURVE('',#1542,#2448); +#2448 = DEFINITIONAL_REPRESENTATION('',(#2449),#2453); +#2449 = LINE('',#2450,#2451); +#2450 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2451 = VECTOR('',#2452,1.); +#2452 = DIRECTION('',(-0.,-1.)); +#2453 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2454 = PCURVE('',#1542,#2455); +#2455 = DEFINITIONAL_REPRESENTATION('',(#2456),#2460); +#2456 = LINE('',#2457,#2458); +#2457 = CARTESIAN_POINT('',(-0.,0.)); +#2458 = VECTOR('',#2459,1.); +#2459 = DIRECTION('',(-0.,-1.)); +#2460 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2461 = ORIENTED_EDGE('',*,*,#1521,.T.); +#2462 = ORIENTED_EDGE('',*,*,#2441,.F.); +#2463 = ADVANCED_FACE('',(#2464),#1577,.F.); +#2464 = FACE_BOUND('',#2465,.T.); +#2465 = EDGE_LOOP('',(#2466,#2494,#2515,#2516)); +#2466 = ORIENTED_EDGE('',*,*,#2467,.T.); +#2467 = EDGE_CURVE('',#2468,#2468,#2470,.T.); +#2468 = VERTEX_POINT('',#2469); +#2469 = CARTESIAN_POINT('',(-28.85,61.6,2.3)); +#2470 = SURFACE_CURVE('',#2471,(#2476,#2483),.PCURVE_S1.); +#2471 = CIRCLE('',#2472,1.15); +#2472 = AXIS2_PLACEMENT_3D('',#2473,#2474,#2475); +#2473 = CARTESIAN_POINT('',(-30.,61.6,2.3)); +#2474 = DIRECTION('',(0.,0.,-1.)); +#2475 = DIRECTION('',(1.,0.,0.)); +#2476 = PCURVE('',#1577,#2477); +#2477 = DEFINITIONAL_REPRESENTATION('',(#2478),#2482); +#2478 = LINE('',#2479,#2480); +#2479 = CARTESIAN_POINT('',(-6.28318530718,-2.3)); +#2480 = VECTOR('',#2481,1.); +#2481 = DIRECTION('',(1.,-0.)); +#2482 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2483 = PCURVE('',#2288,#2484); +#2484 = DEFINITIONAL_REPRESENTATION('',(#2485),#2493); +#2485 = ( BOUNDED_CURVE() B_SPLINE_CURVE(2,(#2486,#2487,#2488,#2489, +#2490,#2491,#2492),.UNSPECIFIED.,.T.,.F.) B_SPLINE_CURVE_WITH_KNOTS((1,2 + ,2,2,2,1),(-2.094395102393,0.,2.094395102393,4.188790204786, +6.28318530718,8.377580409573),.UNSPECIFIED.) CURVE() +GEOMETRIC_REPRESENTATION_ITEM() RATIONAL_B_SPLINE_CURVE((1.,0.5,1.,0.5, +1.,0.5,1.)) REPRESENTATION_ITEM('') ); +#2486 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2487 = CARTESIAN_POINT('',(1.15,-1.991858428704)); +#2488 = CARTESIAN_POINT('',(-0.575,-0.995929214352)); +#2489 = CARTESIAN_POINT('',(-2.3,6.823758593797E-15)); +#2490 = CARTESIAN_POINT('',(-0.575,0.995929214352)); +#2491 = CARTESIAN_POINT('',(1.15,1.991858428704)); +#2492 = CARTESIAN_POINT('',(1.15,7.105427357601E-15)); +#2493 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2494 = ORIENTED_EDGE('',*,*,#2495,.T.); +#2495 = EDGE_CURVE('',#2468,#1557,#2496,.T.); +#2496 = SEAM_CURVE('',#2497,(#2501,#2508),.PCURVE_S1.); +#2497 = LINE('',#2498,#2499); +#2498 = CARTESIAN_POINT('',(-28.85,61.6,0.)); +#2499 = VECTOR('',#2500,1.); +#2500 = DIRECTION('',(0.,0.,1.)); +#2501 = PCURVE('',#1577,#2502); +#2502 = DEFINITIONAL_REPRESENTATION('',(#2503),#2507); +#2503 = LINE('',#2504,#2505); +#2504 = CARTESIAN_POINT('',(-6.28318530718,0.)); +#2505 = VECTOR('',#2506,1.); +#2506 = DIRECTION('',(-0.,-1.)); +#2507 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2508 = PCURVE('',#1577,#2509); +#2509 = DEFINITIONAL_REPRESENTATION('',(#2510),#2514); +#2510 = LINE('',#2511,#2512); +#2511 = CARTESIAN_POINT('',(-0.,0.)); +#2512 = VECTOR('',#2513,1.); +#2513 = DIRECTION('',(-0.,-1.)); +#2514 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#2515 = ORIENTED_EDGE('',*,*,#1556,.T.); +#2516 = ORIENTED_EDGE('',*,*,#2495,.F.); +#2517 = ADVANCED_FACE('',(#2518,#2521),#2123,.F.); +#2518 = FACE_BOUND('',#2519,.F.); +#2519 = EDGE_LOOP('',(#2520)); +#2520 = ORIENTED_EDGE('',*,*,#2108,.T.); +#2521 = FACE_BOUND('',#2522,.F.); +#2522 = EDGE_LOOP('',(#2523)); +#2523 = ORIENTED_EDGE('',*,*,#2305,.T.); +#2524 = ADVANCED_FACE('',(#2525,#2528),#2178,.F.); +#2525 = FACE_BOUND('',#2526,.F.); +#2526 = EDGE_LOOP('',(#2527)); +#2527 = ORIENTED_EDGE('',*,*,#2163,.T.); +#2528 = FACE_BOUND('',#2529,.F.); +#2529 = EDGE_LOOP('',(#2530)); +#2530 = ORIENTED_EDGE('',*,*,#2359,.T.); +#2531 = ADVANCED_FACE('',(#2532,#2535),#2233,.F.); +#2532 = FACE_BOUND('',#2533,.F.); +#2533 = EDGE_LOOP('',(#2534)); +#2534 = ORIENTED_EDGE('',*,*,#2218,.T.); +#2535 = FACE_BOUND('',#2536,.F.); +#2536 = EDGE_LOOP('',(#2537)); +#2537 = ORIENTED_EDGE('',*,*,#2413,.T.); +#2538 = ADVANCED_FACE('',(#2539,#2542),#2288,.F.); +#2539 = FACE_BOUND('',#2540,.F.); +#2540 = EDGE_LOOP('',(#2541)); +#2541 = ORIENTED_EDGE('',*,*,#2273,.T.); +#2542 = FACE_BOUND('',#2543,.F.); +#2543 = EDGE_LOOP('',(#2544)); +#2544 = ORIENTED_EDGE('',*,*,#2467,.T.); +#2545 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#2549)) +GLOBAL_UNIT_ASSIGNED_CONTEXT((#2546,#2547,#2548)) REPRESENTATION_CONTEXT +('Context #1','3D Context with UNIT and UNCERTAINTY') ); +#2546 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#2547 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#2548 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#2549 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#2546, + 'distance_accuracy_value','confusion accuracy'); +#2550 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +ENDSEC; +END-ISO-10303-21; diff --git a/3d_models/parts/hd1370a/stl/BottomCover.stl b/3d_models/parts/hd1370a/stl/BottomCover.stl new file mode 100644 index 0000000..6a98b2e Binary files /dev/null and b/3d_models/parts/hd1370a/stl/BottomCover.stl differ diff --git a/REUSE.toml b/REUSE.toml index 3789532..b6cb49a 100644 --- a/REUSE.toml +++ b/REUSE.toml @@ -39,3 +39,9 @@ SPDX-License-Identifier = "CERN-OHL-S-2.0" path = "hardware/boards/compact-carrier-board/**" SPDX-FileCopyrightText = "2026 Jon Truland" SPDX-License-Identifier = "CERN-OHL-S-2.0" + +[[annotations]] +path = ["3d_models/cad/TinyEngineer.f3d", "3d_models/cad/bottom-cover/**", "3d_models/parts/hd1370a/bottom-cover/**", "3d_models/parts/hd1370a/3mf/BottomCover.3mf", "3d_models/parts/hd1370a/stl/BottomCover.stl", "3d_models/parts/hd1370a/step/BottomCover.step"] +precedence = "override" +SPDX-FileCopyrightText = ["2026 Krzysztof Jamroz", "2026 Hanson Wen"] +SPDX-License-Identifier = "CERN-OHL-S-2.0"