change server path for vscode extension (#5769)

change server path

Signed-off-by: Jess Frazelle <github@jessfraz.com>

.github/workflows/cargo-bench.yml

@@ -0,0 +1,61 @@
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - '**.rs'
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+      - '**/rust-toolchain.toml'
+      - .github/workflows/cargo-bench.yml
+  pull_request:
+    paths:
+      - '**.rs'
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+      - '**/rust-toolchain.toml'
+      - .github/workflows/cargo-bench.yml
+  workflow_dispatch:
+permissions:
+  contents: read
+  pull-requests: write
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+name: cargo bench
+jobs:
+  cargo-bench:
+    name: cargo bench
+    runs-on:
+      - runs-on=${{ github.run_id }}
+      - runner=32cpu-linux-x64
+      - extras=s3-cache
+    steps:
+      - uses: runs-on/action@v1
+      - uses: actions/checkout@v4
+      - name: Use correct Rust toolchain
+        shell: bash
+        run: |
+          [ -e rust-toolchain.toml ] || cp rust/rust-toolchain.toml ./
+      - name: Install rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          cache: rust
+      - name: Install dependencies
+        run: |
+          cargo install cargo-criterion
+          cargo install cargo-codspeed
+          cd rust/kcl-lib
+          cargo add --dev codspeed-criterion-compat --rename criterion
+      - name: Build the benchmark target(s)
+        run: |
+          cd rust
+          cargo codspeed build
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+          working-directory: rust
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}
+        env:
+          KITTYCAD_API_TOKEN: ${{ secrets.KITTYCAD_API_TOKEN }}

.github/workflows/e2e-tests.yml

@@ -26,9 +26,11 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+
       - name: Fetch the base branch
         if: ${{ github.event_name == 'pull_request' }}
         run: git fetch origin ${{ github.base_ref }} --depth=1
+
       - name: Check for path changes
         id: path-changes
         shell: bash
@@ -48,6 +50,7 @@ jobs:
           else
             echo "significant=false" >> $GITHUB_OUTPUT
           fi
+
       - name: Should run
         id: should-run
         shell: bash
@@ -60,6 +63,7 @@ jobs:
           else
             echo "should-run=false" >> $GITHUB_OUTPUT
           fi
+
       - name: Display conditions
         shell: bash
         run: |
@@ -68,7 +72,216 @@ jobs:
           echo "significant: ${{ steps.path-changes.outputs.significant }}"
           echo "should-run: ${{ steps.should-run.outputs.should-run }}"
 
+
+  prepare-wasm:
+    # seperate job on Ubuntu to build or fetch the wasm blob once on the fastest runner
+    runs-on: namespace-profile-ubuntu-8-cores
+    needs: conditions
+    steps:
+      - uses: actions/checkout@v4
+        if: needs.conditions.outputs.should-run == 'true'
+
+      - id: filter
+        if: needs.conditions.outputs.should-run == 'true'
+        name: Check for Rust changes
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            rust:
+              - 'rust/**'
+
+      - uses: actions/setup-node@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'yarn'
+
+      - name: Install dependencies
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn
+
+      - name: Download Wasm Cache
+        id: download-wasm
+        if: ${{ needs.conditions.outputs.should-run == 'true' && github.event_name != 'schedule' && steps.filter.outputs.rust == 'false' }}
+        uses: dawidd6/action-download-artifact@v7
+        continue-on-error: true
+        with:
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          name: wasm-bundle
+          workflow: build-and-store-wasm.yml
+          branch: main
+          path: rust/kcl-wasm-lib/pkg
+
+      - name: Build WASM condition
+        id: wasm
+        if: needs.conditions.outputs.should-run == 'true'
+        run: |
+          set -euox pipefail
+          # Build wasm if this is a scheduled run, there are Rust changes, or
+          # downloading from the wasm cache failed.
+          if [[ ${{github.event_name}} == 'schedule' || ${{steps.filter.outputs.rust}} == 'true' || ${{steps.download-wasm.outcome}} == 'failure' ]]; then
+            echo "should-build-wasm=true" >> $GITHUB_OUTPUT
+          else
+            echo "should-build-wasm=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Use correct Rust toolchain
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
+        shell: bash
+        run: |
+          [ -e rust-toolchain.toml ] || cp rust/rust-toolchain.toml ./
+
+      - name: Install rust
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          cache: false # Configured below.
+
+      - uses: taiki-e/install-action@955a6ff1416eae278c9f833008a9beb4b7f9afe3
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
+        with:
+          tool: wasm-pack
+
+      - name: Rust Cache
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: './rust'
+
+      - name: Build Wasm
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
+        shell: bash
+        run: yarn build:wasm
+
+      - uses: actions/upload-artifact@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        with:
+          name: prepared-wasm
+          path: |
+            rust/kcl-wasm-lib/pkg/kcl_wasm_lib*
+  
+
+  snapshots:
+    name: playwright:snapshots:ubuntu
+    runs-on: namespace-profile-ubuntu-8-cores
+    needs: [conditions, prepare-wasm]
+    steps:
+      - uses: actions/create-github-app-token@v1
+        if: needs.conditions.outputs.should-run == 'true'
+        id: app-token
+        with:
+          app-id: ${{ secrets.MODELING_APP_GH_APP_ID }}
+          private-key: ${{ secrets.MODELING_APP_GH_APP_PRIVATE_KEY }}
+          owner: ${{ github.repository_owner }}
+
+      - uses: actions/checkout@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+
+      - uses: actions/download-artifact@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        name: prepared-wasm
+
+      - name: Copy prepared wasm
+        if: needs.conditions.outputs.should-run == 'true'
+        run: |
+          ls -R prepared-wasm
+          cp prepared-wasm/kcl_wasm_lib_bg.wasm public
+          mkdir rust/kcl-wasm-lib/pkg
+          cp prepared-wasm/kcl_wasm_lib* rust/kcl-wasm-lib/pkg
+
+      - uses: actions/setup-node@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'yarn'
+
+      - name: Install dependencies
+        id: deps-install
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn
+
+      - name: Cache Playwright Browsers
+        if: needs.conditions.outputs.should-run == 'true'
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/ms-playwright/
+          key: ${{ runner.os }}-playwright-${{ hashFiles('yarn.lock') }}
+
+      - name: Install Playwright Browsers
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn playwright install --with-deps
+
+      - name: build web
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn tronb:vite:dev
+
+      - name: Run ubuntu/chrome snapshots
+        if: needs.conditions.outputs.should-run == 'true'
+        run: |
+          yarn test:snapshots
+        env:
+          CI: true
+          NODE_ENV: development
+          VITE_KC_DEV_TOKEN: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
+          VITE_KC_SKIP_AUTH: true
+          token: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
+          snapshottoken: ${{ secrets.KITTYCAD_API_TOKEN }}
+
+      - uses: actions/upload-artifact@v4
+        if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
+        with:
+          name: playwright-report-snapshots-${{ matrix.os }}-snapshot-${{ matrix.shardIndex }}-${{ github.sha }}
+          path: playwright-report/
+          include-hidden-files: true
+          retention-days: 30
+          overwrite: true
+
+      - name: Clean up test-results
+        if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
+        continue-on-error: true
+        run: rm -r test-results
+
+      - name: check for changes
+        if: ${{ needs.conditions.outputs.should-run == 'true' && matrix.os == 'namespace-profile-ubuntu-8-cores' && matrix.shardIndex == 1 && github.ref != 'refs/heads/main' }}
+        shell: bash
+        id: git-check
+        run: |
+            git add e2e/playwright/snapshot-tests.spec.ts-snapshots e2e/playwright/snapshots
+            if git status | grep -q "Changes to be committed"
+            then echo "modified=true" >> $GITHUB_OUTPUT
+            else echo "modified=false" >> $GITHUB_OUTPUT
+            fi
+
+      - name: Commit changes, if any
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.git-check.outputs.modified == 'true' }}
+        shell: bash
+        run: |
+          git add e2e/playwright/snapshot-tests.spec.ts-snapshots e2e/playwright/snapshots
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git remote set-url origin https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git
+          git fetch origin
+          echo ${{ github.head_ref }}
+          git checkout ${{ github.head_ref }}
+          git commit -m "A snapshot a day keeps the bugs away! 📷🐛 (OS: ${{matrix.os}})" || true
+          git push
+          git push origin ${{ github.head_ref }}
+
+      # only upload artifacts if there's actually changes
+      - uses: actions/upload-artifact@v4
+        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.git-check.outputs.modified == 'true' }}
+        with:
+          name: playwright-report-ubuntu-${{ github.sha }}
+          path: playwright-report/
+          include-hidden-files: true
+          retention-days: 30
+
+
   electron:
+    needs: [conditions, prepare-wasm]
     timeout-minutes: 60
     name: playwright:electron:${{ matrix.os }} ${{ matrix.shardIndex }} ${{ matrix.shardTotal }}
     strategy:
@@ -80,218 +293,94 @@ jobs:
         shardTotal: [4]
         # TODO: add ref here for main and latest release tag
     runs-on: ${{ matrix.os }}
-    needs: conditions
     steps:
-    - uses: actions/create-github-app-token@v1
-      id: app-token
-      with:
-        app-id: ${{ secrets.MODELING_APP_GH_APP_ID }}
-        private-key: ${{ secrets.MODELING_APP_GH_APP_PRIVATE_KEY }}
-        owner: ${{ github.repository_owner }}
-    - uses: actions/checkout@v4
-      with:
-        token: ${{ steps.app-token.outputs.token }}
-    - id: filter
-      name: Check for Rust changes
-      uses: dorny/paths-filter@v3
-      with:
-        filters: |
-          rust:
-            - 'rust/**'
-    - uses: actions/setup-node@v4
-      if: needs.conditions.outputs.should-run == 'true'
-      with:
-        node-version-file: '.nvmrc'
-        cache: 'yarn'
-    - name: Install dependencies
-      id: deps-install
-      if: needs.conditions.outputs.should-run == 'true'
-      shell: bash
-      run: yarn
-    - name: Cache Playwright Browsers
-      if: needs.conditions.outputs.should-run == 'true'
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.cache/ms-playwright/
-        key: ${{ runner.os }}-playwright-${{ hashFiles('yarn.lock') }}
-    - name: Install Playwright Browsers
-      if: needs.conditions.outputs.should-run == 'true'
-      shell: bash
-      run: yarn playwright install --with-deps
-    - name: Download Wasm Cache
-      id: download-wasm
-      if: ${{ needs.conditions.outputs.should-run == 'true' && github.event_name != 'schedule' && steps.filter.outputs.rust == 'false' }}
-      uses: dawidd6/action-download-artifact@v7
-      continue-on-error: true
-      with:
-        github_token: ${{secrets.GITHUB_TOKEN}}
-        name: wasm-bundle
-        workflow: build-and-store-wasm.yml
-        branch: main
-        path: rust/kcl-wasm-lib/pkg
-    - name: copy wasm blob
-      if: ${{ needs.conditions.outputs.should-run == 'true' && github.event_name != 'schedule' && steps.filter.outputs.rust == 'false' }}
-      shell: bash
-      run: cp rust/kcl-wasm-lib/pkg/kcl_wasm_lib_bg.wasm public
-      continue-on-error: true
-    - name: Build WASM condition
-      id: wasm
-      if: needs.conditions.outputs.should-run == 'true'
-      shell: bash
-      run: |
-        set -euox pipefail
-        # Build wasm if this is a scheduled run, there are Rust changes, or
-        # downloading from the wasm cache failed.
-        if [[ ${{github.event_name}} == 'schedule' || ${{steps.filter.outputs.rust}} == 'true' || ${{steps.download-wasm.outcome}} == 'failure' ]]; then
-          echo "should-build-wasm=true" >> $GITHUB_OUTPUT
-        else
-          echo "should-build-wasm=false" >> $GITHUB_OUTPUT
-        fi
-    - name: Use correct Rust toolchain
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
-      shell: bash
-      run: |
-        [ -e rust-toolchain.toml ] || cp rust/rust-toolchain.toml ./
-    - name: Install rust
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
-      uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        cache: false # Configured below.
-    - uses: taiki-e/install-action@955a6ff1416eae278c9f833008a9beb4b7f9afe3
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
-      with:
-        tool: wasm-pack
-    - name: Rust Cache
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
-      uses: Swatinem/rust-cache@v2
-      with:
-        workspaces: './rust'
-    - name: install good sed
-      if: ${{ needs.conditions.outputs.should-run == 'true' && startsWith(matrix.os, 'macos') }}
-      shell: bash
-      run: |
-        brew install gnu-sed
-        echo "/opt/homebrew/opt/gnu-sed/libexec/gnubin" >> $GITHUB_PATH
-    - name: Install vector
-      shell: bash
-      # TODO: figure out what to do with this, it's failing
-      if: false
-      run: |
-        curl --proto '=https' --tlsv1.2 -sSfL https://sh.vector.dev > /tmp/vector.sh
-        chmod +x /tmp/vector.sh
-        /tmp/vector.sh -y -no-modify-path
-        mkdir -p /tmp/vector
-        cp .github/workflows/vector.toml /tmp/vector.toml
-        sed -i "s#GITHUB_WORKFLOW#${GITHUB_WORKFLOW}#g" /tmp/vector.toml
-        sed -i "s#GITHUB_REPOSITORY#${GITHUB_REPOSITORY}#g" /tmp/vector.toml
-        sed -i "s#GITHUB_SHA#${GITHUB_SHA}#g" /tmp/vector.toml
-        sed -i "s#GITHUB_REF_NAME#${GITHUB_REF_NAME}#g" /tmp/vector.toml
-        sed -i "s#GH_ACTIONS_AXIOM_TOKEN#${{secrets.GH_ACTIONS_AXIOM_TOKEN}}#g" /tmp/vector.toml
-        cat /tmp/vector.toml
-        ${HOME}/.vector/bin/vector --config /tmp/vector.toml &
-    - name: Build Wasm
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.wasm.outputs.should-build-wasm == 'true' }}
-      shell: bash
-      run: yarn build:wasm
-    - name: build web
-      if: needs.conditions.outputs.should-run == 'true'
-      shell: bash
-      run: yarn tronb:vite:dev
-    - name: Run ubuntu/chrome snapshots
-      if: ${{ needs.conditions.outputs.should-run == 'true' && matrix.os == 'namespace-profile-ubuntu-8-cores' && matrix.shardIndex == 1 }}
-      shell: bash
-      # TODO: break this in its own job, for now it's not slowing down the overall execution as ubuntu is the quickest,
-      # but we could do better. This forces a large 1/1 shard of all 20 snapshot tests that runs in about 3 minutes.
-      run: |
-        yarn test:snapshots
-      env:
-        CI: true
-        NODE_ENV: development
-        VITE_KC_DEV_TOKEN: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
-        VITE_KC_SKIP_AUTH: true
-        token: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
-        snapshottoken: ${{ secrets.KITTYCAD_API_TOKEN }}
-    - uses: actions/upload-artifact@v4
-      if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
-      with:
-        name: playwright-report-snapshots-${{ matrix.os }}-snapshot-${{ matrix.shardIndex }}-${{ github.sha }}
-        path: playwright-report/
-        include-hidden-files: true
-        retention-days: 30
-        overwrite: true
-    - name: Clean up test-results
-      if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
-      continue-on-error: true
-      run: rm -r test-results
-    - name: check for changes
-      if: ${{ needs.conditions.outputs.should-run == 'true' && matrix.os == 'namespace-profile-ubuntu-8-cores' && matrix.shardIndex == 1 && github.ref != 'refs/heads/main' }}
-      shell: bash
-      id: git-check
-      run: |
-          git add e2e/playwright/snapshot-tests.spec.ts-snapshots e2e/playwright/snapshots
-          if git status | grep -q "Changes to be committed"
-          then echo "modified=true" >> $GITHUB_OUTPUT
-          else echo "modified=false" >> $GITHUB_OUTPUT
-          fi
-    - name: Commit changes, if any
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.git-check.outputs.modified == 'true' }}
-      shell: bash
-      run: |
-        git add e2e/playwright/snapshot-tests.spec.ts-snapshots e2e/playwright/snapshots
-        git config --local user.email "github-actions[bot]@users.noreply.github.com"
-        git config --local user.name "github-actions[bot]"
-        git remote set-url origin https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git
-        git fetch origin
-        echo ${{ github.head_ref }}
-        git checkout ${{ github.head_ref }}
-        git commit -m "A snapshot a day keeps the bugs away! 📷🐛 (OS: ${{matrix.os}})" || true
-        git push
-        git push origin ${{ github.head_ref }}
-    # only upload artifacts if there's actually changes
-    - uses: actions/upload-artifact@v4
-      if: ${{ needs.conditions.outputs.should-run == 'true' && steps.git-check.outputs.modified == 'true' }}
-      with:
-        name: playwright-report-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
-        path: playwright-report/
-        include-hidden-files: true
-        retention-days: 30
-    - uses: actions/download-artifact@v4
-      if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
-      continue-on-error: true
-      with:
-        name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
-        path: test-results/
-    - name: Run playwright/electron flow (with retries)
-      id: retry
-      if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && steps.deps-install.outcome == 'success' }}
-      uses: nick-fields/retry@v3.0.2
-      with:
-        shell: bash
-        command: .github/ci-cd-scripts/playwright-electron.sh ${{matrix.shardIndex}} ${{matrix.shardTotal}} ${{matrix.os}}
-        timeout_minutes: 30
-        max_attempts: 25
-      env:
-        CI: true
-        FAIL_ON_CONSOLE_ERRORS: true
-        NODE_ENV: development
-        VITE_KC_DEV_TOKEN: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
-        VITE_KC_SKIP_AUTH: true
-        token: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
-    - uses: actions/upload-artifact@v4
-      if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
-      with:
-        name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
-        path: test-results/
-        include-hidden-files: true
-        retention-days: 30
-        overwrite: true
-    - uses: actions/upload-artifact@v4
-      if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
-      with:
-        name: playwright-report-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
-        path: playwright-report/
-        include-hidden-files: true
-        retention-days: 30
-        overwrite: true
+      - uses: actions/checkout@v4
+        if: needs.conditions.outputs.should-run == 'true'
 
+      - uses: actions/download-artifact@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        name: prepared-wasm
+
+      - name: Copy prepared wasm
+        if: needs.conditions.outputs.should-run == 'true'
+        run: |
+          ls -R prepared-wasm
+          cp prepared-wasm/kcl_wasm_lib_bg.wasm public
+          mkdir rust/kcl-wasm-lib/pkg
+          cp prepared-wasm/kcl_wasm_lib* rust/kcl-wasm-lib/pkg
+
+      - uses: actions/setup-node@v4
+        if: needs.conditions.outputs.should-run == 'true'
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'yarn'
+
+      - name: Install dependencies
+        id: deps-install
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn
+
+      - name: Cache Playwright Browsers
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/ms-playwright/
+          key: ${{ runner.os }}-playwright-${{ hashFiles('yarn.lock') }}
+
+      - name: Install Playwright Browsers
+        run: yarn playwright install --with-deps
+
+      - name: Build web
+        if: needs.conditions.outputs.should-run == 'true'
+        run: yarn tronb:vite:dev
+
+      - name: Install good sed
+        if: startsWith(matrix.os, 'macos')
+        shell: bash
+        run: |
+          brew install gnu-sed
+          echo "/opt/homebrew/opt/gnu-sed/libexec/gnubin" >> $GITHUB_PATH
+
+        # TODO: Add back axiom logs
+
+      - uses: actions/download-artifact@v4
+        if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
+        continue-on-error: true
+        with:
+          name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          path: test-results/
+
+      - name: Run playwright/electron flow (with retries)
+        id: retry
+        if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && steps.deps-install.outcome == 'success' }}
+        uses: nick-fields/retry@v3.0.2
+        with:
+          shell: bash
+          command: .github/ci-cd-scripts/playwright-electron.sh ${{matrix.shardIndex}} ${{matrix.shardTotal}} ${{matrix.os}}
+          timeout_minutes: 30
+          max_attempts: 25
+        env:
+          CI: true
+          FAIL_ON_CONSOLE_ERRORS: true
+          NODE_ENV: development
+          VITE_KC_DEV_TOKEN: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
+          VITE_KC_SKIP_AUTH: true
+          token: ${{ secrets.KITTYCAD_API_TOKEN_DEV }}
+
+      - uses: actions/upload-artifact@v4
+        if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
+        with:
+          name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          path: test-results/
+          include-hidden-files: true
+          retention-days: 30
+          overwrite: true
+
+      - uses: actions/upload-artifact@v4
+        if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
+        with:
+          name: playwright-report-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          path: playwright-report/
+          include-hidden-files: true
+          retention-days: 30
+          overwrite: true

.github/workflows/generate-website-docs.yml

@@ -40,9 +40,13 @@ jobs:
           # cleanup old
           rm -rf documentation/content/pages/docs/kcl/*.md
           rm -rf documentation/content/pages/docs/kcl/types
+          rm -rf documentation/content/pages/docs/kcl/settings
+          rm -rf documentation/content/pages/docs/kcl/consts
           # move new
           mv -f docs/kcl/*.md documentation/content/pages/docs/kcl/
           mv -f docs/kcl/types documentation/content/pages/docs/kcl/
+          mv -f docs/kcl/settings documentation/content/pages/docs/kcl/
+          mv -f docs/kcl/consts documentation/content/pages/docs/kcl/
       - name: move kcl-samples
         shell: bash
         run: |

.github/workflows/kcl-python-bindings.yml

@@ -161,6 +161,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v4
+        with:
+          path: rust/kcl-python-bindings
       - name: Install the latest version of uv
         uses: astral-sh/setup-uv@v5
       - name: do uv things

docs/kcl/consts.md

@@ -0,0 +1,25 @@
+---
+title: "KCL Constants"
+excerpt: "Documentation for the KCL constants."
+layout: manual
+---
+
+## Table of Contents
+
+
+### `std`
+
+- [`HALF_TURN`](/docs/kcl/consts/std-HALF_TURN)
+- [`QUARTER_TURN`](/docs/kcl/consts/std-QUARTER_TURN)
+- [`THREE_QUARTER_TURN`](/docs/kcl/consts/std-THREE_QUARTER_TURN)
+- [`XY`](/docs/kcl/consts/std-XY)
+- [`XZ`](/docs/kcl/consts/std-XZ)
+- [`YZ`](/docs/kcl/consts/std-YZ)
+- [`ZERO`](/docs/kcl/consts/std-ZERO)
+
+### `std::math`
+
+- [`E`](/docs/kcl/consts/std-math-E)
+- [`PI`](/docs/kcl/consts/std-math-PI)
+- [`TAU`](/docs/kcl/consts/std-math-TAU)
+

docs/kcl/index.md

@@ -12,25 +12,26 @@ layout: manual
 * [`Modules`](kcl/modules)
 * [`Settings`](kcl/settings)
 * [`Known Issues`](kcl/known-issues)
+* [`Constants`](kcl/consts)
 
 ### Standard library
 
 * **Primitive types**
-  * [`bool`](kcl/bool)
-  * [`number`](kcl/number)
-  * [`string`](kcl/string)
-  * [`tag`](kcl/tag)
+  * [`bool`](kcl/types/bool)
+  * [`number`](kcl/types/number)
+  * [`string`](kcl/types/string)
+  * [`tag`](kcl/types/tag)
 * **std**
-  * [`HALF_TURN`](kcl/const_std-HALF_TURN)
-  * [`Plane`](kcl/Plane)
-  * [`QUARTER_TURN`](kcl/const_std-QUARTER_TURN)
-  * [`Sketch`](kcl/Sketch)
-  * [`Solid`](kcl/Solid)
-  * [`THREE_QUARTER_TURN`](kcl/const_std-THREE_QUARTER_TURN)
-  * [`XY`](kcl/const_std-XY)
-  * [`XZ`](kcl/const_std-XZ)
-  * [`YZ`](kcl/const_std-YZ)
-  * [`ZERO`](kcl/const_std-ZERO)
+  * [`HALF_TURN`](kcl/consts/std-HALF_TURN)
+  * [`Plane`](kcl/types/Plane)
+  * [`QUARTER_TURN`](kcl/consts/std-QUARTER_TURN)
+  * [`Sketch`](kcl/types/Sketch)
+  * [`Solid`](kcl/types/Solid)
+  * [`THREE_QUARTER_TURN`](kcl/consts/std-THREE_QUARTER_TURN)
+  * [`XY`](kcl/consts/std-XY)
+  * [`XZ`](kcl/consts/std-XZ)
+  * [`YZ`](kcl/consts/std-YZ)
+  * [`ZERO`](kcl/consts/std-ZERO)
   * [`abs`](kcl/abs)
   * [`acos`](kcl/acos)
   * [`angleToMatchLengthX`](kcl/angleToMatchLengthX)
@@ -134,9 +135,9 @@ layout: manual
   * [`yLine`](kcl/yLine)
   * [`yd`](kcl/yd)
 * **std::math**
-  * [`E`](kcl/const_std-math-E)
-  * [`PI`](kcl/const_std-math-PI)
-  * [`TAU`](kcl/const_std-math-TAU)
+  * [`E`](kcl/consts/std-math-E)
+  * [`PI`](kcl/consts/std-math-PI)
+  * [`TAU`](kcl/consts/std-math-TAU)
   * [`cos`](kcl/std-math-cos)
   * [`sin`](kcl/std-math-sin)
   * [`tan`](kcl/std-math-tan)

docs/kcl/known-issues.md

@@ -13,9 +13,7 @@ once fixed in engine will just start working here with no language changes.
     If you see a red line around your model, it means this is happening.
 
 - **Import**: Right now you can import a file, even if that file has brep data
-    you cannot edit it, after v1, the engine will account for this. You also cannot
-    currently move or transform the imported objects at all, once we have assemblies
-    this will work.
+    you cannot edit it, after v1, the engine will account for this. 
 
 - **Fillets**: Fillets cannot intersect, you will get an error. Only simple fillet
     cases work currently.

docs/kcl/settings.md

@@ -1,16 +1,31 @@
 ---
-title: "KCL settings"
+title: "KCL Settings"
 excerpt: "Documentation of settings for the KCL language and Zoo Modeling App."
 layout: manual
 ---
 
-# Per-file settings
+# KCL Settings
+
+There are three levels of settings available in the KittyCAD modeling application:
+
+1. [User Settings](/docs/kcl/settings/user): Global settings that apply to all projects, stored in `user.toml`
+2. [Project Settings](/docs/kcl/settings/project): Settings specific to a project, stored in `project.toml`
+3. Per-file Settings: Settings that apply to a single KCL file, specified using the `@settings` attribute
+
+## Configuration Files
+
+The KittyCAD modeling app uses TOML files for configuration:
+
+* **User Settings**: `user.toml` - See [complete documentation](/docs/kcl/settings/user)
+* **Project Settings**: `project.toml` - See [complete documentation](/docs/kcl/settings/project)
+
+## Per-file settings
 
 Settings which affect a single file are configured using the settings attribute.
 This must be at the top of the KCL file (comments before the attribute are permitted).
-E.g.,
+For example:
 
-```
+```js
 // The settings attribute.
 @settings(defaultLengthUnit = in)
 

docs/kcl/settings/project.md

@@ -0,0 +1,208 @@
+---
+title: "Project Settings"
+excerpt: "Project specific settings for the app. These live in `project.toml` in the base of the project directory. Updating the settings for the project in the app will update this file automatically. Do not edit this file manually, as it may be overwritten by the app. Manual edits can cause corruption of the settings file."
+layout: manual
+---
+
+# Project Settings
+
+Project specific settings for the app. These live in `project.toml` in the base of the project directory. Updating the settings for the project in the app will update this file automatically. Do not edit this file manually, as it may be overwritten by the app. Manual edits can cause corruption of the settings file.
+
+## Project Configuration Structure
+
+```toml
+[settings.app]
+# Set the appearance of the application
+name = "My Awesome Project"
+
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark" 
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use inches as the default measurement unit
+base_unit = "in"
+
+```
+
+## Available Settings
+
+### settings
+
+
+
+#### app
+
+The settings for the modeling app.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### appearance
+
+The settings for the appearance of the app.
+
+
+**Default:** None
+
+This setting has further nested options. See the schema for full details.
+##### onboarding_status
+
+The onboarding status of the app.
+
+
+**Default:** None
+
+##### theme_color
+
+The hue of the primary theme color for the app.
+
+
+**Default:** None
+
+##### enable_ssao
+
+Whether or not Screen Space Ambient Occlusion (SSAO) is enabled.
+
+
+**Default:** None
+
+##### dismiss_web_banner
+
+Permanently dismiss the banner warning to download the desktop app. This setting only applies to the web app. And is temporary until we have Linux support.
+
+
+**Default:** None
+
+##### stream_idle_mode
+
+When the user is idle, and this is true, the stream will be torn down.
+
+
+**Default:** None
+
+##### allow_orbit_in_sketch_mode
+
+When the user is idle, and this is true, the stream will be torn down.
+
+
+**Default:** None
+
+##### show_debug_panel
+
+Whether to show the debug panel, which lets you see various states of the app to aid in development.
+
+
+**Default:** None
+
+##### named_views
+
+Settings that affect the behavior of the command bar.
+
+
+**Default:** None
+
+
+#### modeling
+
+Settings that affect the behavior while modeling.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### base_unit
+
+The default unit to use in modeling dimensions.
+
+
+**Default:** None
+
+##### highlight_edges
+
+Highlight edges of 3D objects?
+
+
+**Default:** None
+
+##### show_debug_panel
+
+Whether to show the debug panel, which lets you see various states of the app to aid in development. Remove this when we remove backwards compatibility with the old settings file.
+
+
+**Default:** None
+
+##### enable_ssao
+
+Whether or not Screen Space Ambient Occlusion (SSAO) is enabled.
+
+
+**Default:** None
+
+
+#### text_editor
+
+Settings that affect the behavior of the KCL text editor.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### text_wrapping
+
+Whether to wrap text in the editor or overflow with scroll.
+
+
+**Default:** None
+
+##### blinking_cursor
+
+Whether to make the cursor blink in the editor.
+
+
+**Default:** None
+
+
+#### command_bar
+
+Settings that affect the behavior of the command bar.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### include_settings
+
+Whether to include settings in the command bar.
+
+
+**Default:** None
+
+
+
+
+## Complete Example
+
+```toml
+[settings.app]
+# Set the appearance of the application
+name = "My Awesome Project"
+
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark" 
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use inches as the default measurement unit
+base_unit = "in"
+
+```

docs/kcl/settings/user.md

@@ -0,0 +1,272 @@
+---
+title: "User Settings"
+excerpt: "User specific settings for the app. These live in `user.toml` in the app's configuration directory. Updating the settings in the app will update this file automatically. Do not edit this file manually, as it may be overwritten by the app. Manual edits can cause corruption of the settings file."
+layout: manual
+---
+
+# User Settings
+
+User specific settings for the app. These live in `user.toml` in the app's configuration directory. Updating the settings in the app will update this file automatically. Do not edit this file manually, as it may be overwritten by the app. Manual edits can cause corruption of the settings file.
+
+## User Configuration Structure
+
+```toml
+[settings.app]
+# Set the appearance of the application
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark"
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use millimeters as the default measurement unit
+base_unit = "mm"
+
+[settings.text_editor]
+# Disable text wrapping in the editor
+text_wrapping = false
+
+```
+
+## Available Settings
+
+### settings
+
+
+
+#### app
+
+The settings for the modeling app.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### appearance
+
+The settings for the appearance of the app.
+
+
+**Default:** None
+
+This setting has further nested options. See the schema for full details.
+##### onboarding_status
+
+The onboarding status of the app.
+
+
+**Default:** None
+
+##### project_directory
+
+Backwards compatible project directory setting.
+
+
+**Default:** None
+
+##### theme
+
+Backwards compatible theme setting.
+
+
+**Default:** None
+
+##### theme_color
+
+The hue of the primary theme color for the app.
+
+
+**Default:** None
+
+##### enable_ssao
+
+Whether or not Screen Space Ambient Occlusion (SSAO) is enabled.
+
+
+**Default:** None
+
+##### dismiss_web_banner
+
+Permanently dismiss the banner warning to download the desktop app. This setting only applies to the web app. And is temporary until we have Linux support.
+
+
+**Default:** None
+
+##### stream_idle_mode
+
+When the user is idle, and this is true, the stream will be torn down.
+
+
+**Default:** None
+
+##### allow_orbit_in_sketch_mode
+
+When the user is idle, and this is true, the stream will be torn down.
+
+
+**Default:** None
+
+##### show_debug_panel
+
+Whether to show the debug panel, which lets you see various states of the app to aid in development.
+
+
+**Default:** None
+
+
+#### modeling
+
+Settings that affect the behavior while modeling.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### base_unit
+
+The default unit to use in modeling dimensions.
+
+
+**Default:** None
+
+##### camera_projection
+
+The projection mode the camera should use while modeling.
+
+
+**Default:** None
+
+##### camera_orbit
+
+The methodology the camera should use to orbit around the model.
+
+
+**Default:** None
+
+##### mouse_controls
+
+The controls for how to navigate the 3D view.
+
+**Possible values:** `zoo`, `onshape`, `trackpad_friendly`, `solidworks`, `nx`, `creo`, `autocad`
+
+**Default:** None
+
+##### highlight_edges
+
+Highlight edges of 3D objects?
+
+
+**Default:** None
+
+##### show_debug_panel
+
+Whether to show the debug panel, which lets you see various states of the app to aid in development. Remove this when we remove backwards compatibility with the old settings file.
+
+
+**Default:** None
+
+##### enable_ssao
+
+Whether or not Screen Space Ambient Occlusion (SSAO) is enabled.
+
+
+**Default:** None
+
+##### show_scale_grid
+
+Whether or not to show a scale grid in the 3D modeling view
+
+
+**Default:** None
+
+
+#### text_editor
+
+Settings that affect the behavior of the KCL text editor.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### text_wrapping
+
+Whether to wrap text in the editor or overflow with scroll.
+
+
+**Default:** None
+
+##### blinking_cursor
+
+Whether to make the cursor blink in the editor.
+
+
+**Default:** None
+
+
+#### project
+
+Settings that affect the behavior of project management.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### directory
+
+The directory to save and load projects from.
+
+
+**Default:** None
+
+##### default_project_name
+
+The default project name to use when creating a new project.
+
+
+**Default:** None
+
+
+#### command_bar
+
+Settings that affect the behavior of the command bar.
+
+
+**Default:** None
+
+This setting has the following nested options:
+
+##### include_settings
+
+Whether to include settings in the command bar.
+
+
+**Default:** None
+
+
+
+
+## Complete Example
+
+```toml
+[settings.app]
+# Set the appearance of the application
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark"
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use millimeters as the default measurement unit
+base_unit = "mm"
+
+[settings.text_editor]
+# Disable text wrapping in the editor
+text_wrapping = false
+
+```

docs/kcl/types/SolidOrImportedGeometry.md

@@ -0,0 +1,62 @@
+---
+title: "SolidOrImportedGeometry"
+excerpt: "Data for a solid or an imported geometry."
+layout: manual
+---
+
+Data for a solid or an imported geometry.
+
+
+
+
+
+**This schema accepts exactly one of the following:**
+
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `solid`|  | No |
+| `id` |[`string`](/docs/kcl/types/string)| The id of the solid. | No |
+| `artifactId` |[`ArtifactId`](/docs/kcl/types/ArtifactId)| The artifact ID of the solid.  Unlike `id`, this doesn't change. | No |
+| `value` |`[` [`ExtrudeSurface`](/docs/kcl/types/ExtrudeSurface) `]`| The extrude surfaces. | No |
+| `sketch` |[`Sketch`](/docs/kcl/types/Sketch)| The sketch. | No |
+| `height` |[`number`](/docs/kcl/types/number)| The height of the solid. | No |
+| `startCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion start cap | No |
+| `endCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion end cap | No |
+| `edgeCuts` |`[` [`EdgeCut`](/docs/kcl/types/EdgeCut) `]`| Chamfers or fillets on this solid. | No |
+| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
+| `__meta` |`[` [`Metadata`](/docs/kcl/types/Metadata) `]`| Metadata. | No |
+
+
+----
+Data for an imported geometry.
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `importedGeometry`|  | No |
+| `id` |[`string`](/docs/kcl/types/string)| The ID of the imported geometry. | No |
+| `value` |`[` [`string`](/docs/kcl/types/string) `]`| The original file paths. | No |
+| `__meta` |`[` [`Metadata`](/docs/kcl/types/Metadata) `]`|  | No |
+
+
+----
+
+
+
+

e2e/playwright/feature-tree-pane.spec.ts

@@ -274,7 +274,6 @@ test.describe('Feature Tree pane', () => {
         currentArgKey: 'distance',
         currentArgValue: initialInput,
         headerArguments: {
-          Selection: '1 face',
           Distance: initialInput,
         },
         highlightedHeaderArg: 'distance',
@@ -291,7 +290,6 @@ test.describe('Feature Tree pane', () => {
       await cmdBar.expectState({
         stage: 'review',
         headerArguments: {
-          Selection: '1 face',
           // The calculated value is shown in the argument summary
           Distance: initialInput,
         },

e2e/playwright/snapshots/prompt-to-edit/prompt-to-edit-snapshot-tests-spec-ts--change-colour.snap.json

@@ -29,5 +29,5 @@
       }
     }
   ],
-  "kcl_version": "0.2.47"
+  "kcl_version": "0.2.48"
 }

e2e/playwright/testing-constraints.spec.ts

@@ -1127,7 +1127,6 @@ test.describe('Electron constraint tests', () => {
           path.join(bracketDir, 'main.kcl')
         )
       })
-      const [clickHandler] = scene.makeMouseHelpers(600, 300)
 
       await test.step('setup test', async () => {
         await homePage.expectState({
@@ -1144,8 +1143,12 @@ test.describe('Electron constraint tests', () => {
       })
 
       await test.step('Double click to constrain', async () => {
-        await clickHandler()
-        await page.getByRole('button', { name: 'Edit Sketch' }).click()
+        // Enter sketch edit mode via feature tree
+        await toolbar.openPane('feature-tree')
+        const op = await toolbar.getFeatureTreeOperation('Sketch', 0)
+        await op.dblclick()
+        await toolbar.closePane('feature-tree')
+
         const child = page
           .locator('.segment-length-label-text')
           .first()

public/kcl-samples/step/pipe-flange-assembly.step

@@ -29,17 +29,17 @@ DATA;
 #13 = VERTEX_POINT('NONE', #12);
 #14 = CARTESIAN_POINT('NONE', (-0.004400550000000005, 0.027303023818752777, 0.0142875));
 #15 = VERTEX_POINT('NONE', #14);
-#16 = CARTESIAN_POINT('NONE', (-0.008801100000000001, 0.034925000000000005, 0.0206375));
+#16 = CARTESIAN_POINT('NONE', (-0.008801100000000003, 0.034925000000000005, 0.0206375));
 #17 = VERTEX_POINT('NONE', #16);
-#18 = CARTESIAN_POINT('NONE', (-0.008801100000000001, 0.034925000000000005, 0.0142875));
+#18 = CARTESIAN_POINT('NONE', (-0.008801100000000003, 0.034925000000000005, 0.0142875));
 #19 = VERTEX_POINT('NONE', #18);
-#20 = CARTESIAN_POINT('NONE', (-0.00440055, 0.042546976181247226, 0.0206375));
+#20 = CARTESIAN_POINT('NONE', (-0.004400550000000001, 0.042546976181247226, 0.0206375));
 #21 = VERTEX_POINT('NONE', #20);
-#22 = CARTESIAN_POINT('NONE', (-0.00440055, 0.042546976181247226, 0.0142875));
+#22 = CARTESIAN_POINT('NONE', (-0.004400550000000001, 0.042546976181247226, 0.0142875));
 #23 = VERTEX_POINT('NONE', #22);
-#24 = CARTESIAN_POINT('NONE', (0.004400550000000001, 0.042546976181247226, 0.0206375));
+#24 = CARTESIAN_POINT('NONE', (0.00440055, 0.042546976181247226, 0.0206375));
 #25 = VERTEX_POINT('NONE', #24);
-#26 = CARTESIAN_POINT('NONE', (0.004400550000000001, 0.042546976181247226, 0.0142875));
+#26 = CARTESIAN_POINT('NONE', (0.00440055, 0.042546976181247226, 0.0142875));
 #27 = VERTEX_POINT('NONE', #26);
 #28 = CARTESIAN_POINT('NONE', (-0.0000000000000000011975821048861966, 0.039814499999999996, 0.0206375));
 #29 = VERTEX_POINT('NONE', #28);
@@ -57,17 +57,17 @@ DATA;
 #41 = VERTEX_POINT('NONE', #40);
 #42 = CARTESIAN_POINT('NONE', (0.01860266554050596, 0.020463645441073146, 0.0142875));
 #43 = VERTEX_POINT('NONE', #42);
-#44 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265653, 0.0206375));
+#44 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265656, 0.0206375));
 #45 = VERTEX_POINT('NONE', #44);
-#46 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265653, 0.0142875));
+#46 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265656, 0.0142875));
 #47 = VERTEX_POINT('NONE', #46);
-#48 = CARTESIAN_POINT('NONE', (0.030520867414747018, 0.029968094279108775, 0.0206375));
+#48 = CARTESIAN_POINT('NONE', (0.030520867414747015, 0.02996809427910878, 0.0206375));
 #49 = VERTEX_POINT('NONE', #48);
-#50 = CARTESIAN_POINT('NONE', (0.030520867414747018, 0.029968094279108775, 0.0142875));
+#50 = CARTESIAN_POINT('NONE', (0.030520867414747015, 0.02996809427910878, 0.0142875));
 #51 = VERTEX_POINT('NONE', #50);
-#52 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.0230871172187594, 0.0206375));
+#52 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.023087117218759404, 0.0206375));
 #53 = VERTEX_POINT('NONE', #52);
-#54 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.0230871172187594, 0.0142875));
+#54 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.023087117218759404, 0.0142875));
 #55 = VERTEX_POINT('NONE', #54);
 #56 = CARTESIAN_POINT('NONE', (0.03112822955872337, 0.024823934716104546, 0.0206375));
 #57 = VERTEX_POINT('NONE', #56);
@@ -85,13 +85,13 @@ DATA;
 #69 = VERTEX_POINT('NONE', #68);
 #70 = CARTESIAN_POINT('NONE', (0.027597694503788704, -0.0017852753360286355, 0.0142875));
 #71 = VERTEX_POINT('NONE', #70);
-#72 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.00080889442947917, 0.0206375));
+#72 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.0008088944294791717, 0.0206375));
 #73 = VERTEX_POINT('NONE', #72);
-#74 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.00080889442947917, 0.0142875));
+#74 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.0008088944294791717, 0.0142875));
 #75 = VERTEX_POINT('NONE', #74);
-#76 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.005177373852916468, 0.0206375));
+#76 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.0051773738529164665, 0.0206375));
 #77 = VERTEX_POINT('NONE', #76);
-#78 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.005177373852916468, 0.0142875));
+#78 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.0051773738529164665, 0.0142875));
 #79 = VERTEX_POINT('NONE', #78);
 #80 = CARTESIAN_POINT('NONE', (0.04050102016211167, -0.013757811900819917, 0.0206375));
 #81 = VERTEX_POINT('NONE', #80);
@@ -113,17 +113,17 @@ DATA;
 #97 = VERTEX_POINT('NONE', #96);
 #98 = CARTESIAN_POINT('NONE', (0.015811096615344203, -0.022689847372120698, 0.0142875));
 #99 = VERTEX_POINT('NONE', #98);
-#100 = CARTESIAN_POINT('NONE', (0.023082906691976702, -0.027647683535144445, 0.0206375));
+#100 = CARTESIAN_POINT('NONE', (0.023082906691976705, -0.027647683535144445, 0.0206375));
 #101 = VERTEX_POINT('NONE', #100);
-#102 = CARTESIAN_POINT('NONE', (0.023082906691976702, -0.027647683535144445, 0.0142875));
+#102 = CARTESIAN_POINT('NONE', (0.023082906691976705, -0.027647683535144445, 0.0142875));
 #103 = VERTEX_POINT('NONE', #102);
-#104 = CARTESIAN_POINT('NONE', (0.02242519966531322, -0.03642417387451573, 0.0206375));
+#104 = CARTESIAN_POINT('NONE', (0.022425199665313224, -0.03642417387451573, 0.0206375));
 #105 = VERTEX_POINT('NONE', #104);
-#106 = CARTESIAN_POINT('NONE', (0.02242519966531322, -0.03642417387451573, 0.0142875));
+#106 = CARTESIAN_POINT('NONE', (0.022425199665313224, -0.03642417387451573, 0.0142875));
 #107 = VERTEX_POINT('NONE', #106);
-#108 = CARTESIAN_POINT('NONE', (0.014495682562017243, -0.040242828050863266, 0.0206375));
+#108 = CARTESIAN_POINT('NONE', (0.014495682562017245, -0.040242828050863266, 0.0206375));
 #109 = VERTEX_POINT('NONE', #108);
-#110 = CARTESIAN_POINT('NONE', (0.014495682562017243, -0.040242828050863266, 0.0142875));
+#110 = CARTESIAN_POINT('NONE', (0.014495682562017245, -0.040242828050863266, 0.0142875));
 #111 = VERTEX_POINT('NONE', #110);
 #112 = CARTESIAN_POINT('NONE', (0.01727486413109602, -0.03587162499110086, 0.0206375));
 #113 = VERTEX_POINT('NONE', #112);
@@ -141,17 +141,17 @@ DATA;
 #125 = VERTEX_POINT('NONE', #124);
 #126 = CARTESIAN_POINT('NONE', (-0.007881579512048209, -0.026508501548468247, 0.014287499999999998));
 #127 = VERTEX_POINT('NONE', #126);
-#128 = CARTESIAN_POINT('NONE', (-0.0072238724853847325, -0.03528499188783953, 0.020637499999999996));
+#128 = CARTESIAN_POINT('NONE', (-0.007223872485384732, -0.03528499188783953, 0.020637499999999996));
 #129 = VERTEX_POINT('NONE', #128);
-#130 = CARTESIAN_POINT('NONE', (-0.0072238724853847325, -0.03528499188783953, 0.014287499999999998));
+#130 = CARTESIAN_POINT('NONE', (-0.007223872485384732, -0.03528499188783953, 0.014287499999999998));
 #131 = VERTEX_POINT('NONE', #130);
-#132 = CARTESIAN_POINT('NONE', (-0.014495682562017234, -0.04024282805086327, 0.020637499999999996));
+#132 = CARTESIAN_POINT('NONE', (-0.014495682562017232, -0.04024282805086327, 0.020637499999999996));
 #133 = VERTEX_POINT('NONE', #132);
-#134 = CARTESIAN_POINT('NONE', (-0.014495682562017234, -0.04024282805086327, 0.014287499999999998));
+#134 = CARTESIAN_POINT('NONE', (-0.014495682562017232, -0.04024282805086327, 0.014287499999999998));
 #135 = VERTEX_POINT('NONE', #134);
-#136 = CARTESIAN_POINT('NONE', (-0.022425199665313218, -0.036424173874515735, 0.020637499999999996));
+#136 = CARTESIAN_POINT('NONE', (-0.022425199665313214, -0.036424173874515735, 0.020637499999999996));
 #137 = VERTEX_POINT('NONE', #136);
-#138 = CARTESIAN_POINT('NONE', (-0.022425199665313218, -0.036424173874515735, 0.014287499999999998));
+#138 = CARTESIAN_POINT('NONE', (-0.022425199665313214, -0.036424173874515735, 0.014287499999999998));
 #139 = VERTEX_POINT('NONE', #138);
 #140 = CARTESIAN_POINT('NONE', (-0.01727486413109601, -0.035871624991100866, 0.020637499999999996));
 #141 = VERTEX_POINT('NONE', #140);
@@ -173,13 +173,13 @@ DATA;
 #157 = VERTEX_POINT('NONE', #156);
 #158 = CARTESIAN_POINT('NONE', (-0.032090928341107286, -0.01635198166632771, 0.0142875));
 #159 = VERTEX_POINT('NONE', #158);
-#160 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.01375781190081989, 0.0206375));
+#160 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.013757811900819893, 0.0206375));
 #161 = VERTEX_POINT('NONE', #160);
-#162 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.01375781190081989, 0.0142875));
+#162 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.013757811900819893, 0.0142875));
 #163 = VERTEX_POINT('NONE', #162);
-#164 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.005177373852916439, 0.0206375));
+#164 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.0051773738529164405, 0.0206375));
 #165 = VERTEX_POINT('NONE', #164);
-#166 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.005177373852916439, 0.0142875));
+#166 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.0051773738529164405, 0.0142875));
 #167 = VERTEX_POINT('NONE', #166);
 #168 = CARTESIAN_POINT('NONE', (-0.038816267359563214, -0.008859559725003652, 0.0206375));
 #169 = VERTEX_POINT('NONE', #168);
@@ -201,9 +201,9 @@ DATA;
 #185 = VERTEX_POINT('NONE', #184);
 #186 = CARTESIAN_POINT('NONE', (-0.032792860620334846, 0.014894404269566884, 0.0142875));
 #187 = VERTEX_POINT('NONE', #186);
-#188 = CARTESIAN_POINT('NONE', (-0.036008263509885924, 0.02308711721875939, 0.0206375));
+#188 = CARTESIAN_POINT('NONE', (-0.03600826350988593, 0.02308711721875939, 0.0206375));
 #189 = VERTEX_POINT('NONE', #188);
-#190 = CARTESIAN_POINT('NONE', (-0.036008263509885924, 0.02308711721875939, 0.0142875));
+#190 = CARTESIAN_POINT('NONE', (-0.03600826350988593, 0.02308711721875939, 0.0142875));
 #191 = VERTEX_POINT('NONE', #190);
 #192 = CARTESIAN_POINT('NONE', (-0.03052086741474703, 0.029968094279108768, 0.0206375));
 #193 = VERTEX_POINT('NONE', #192);
@@ -715,49 +715,49 @@ DATA;
 #699 = VECTOR('NONE', #698, 1);
 #700 = CARTESIAN_POINT('NONE', (0.004400549999999997, 0.027303023818752777, 0.0142875));
 #701 = LINE('NONE', #700, #699);
-#702 = DIRECTION('NONE', (-0.49999999999999944, 0.866025403784439, 0));
+#702 = DIRECTION('NONE', (-0.49999999999999956, 0.8660254037844389, 0));
 #703 = VECTOR('NONE', #702, 1);
 #704 = CARTESIAN_POINT('NONE', (-0.004400550000000005, 0.027303023818752777, 0.0206375));
 #705 = LINE('NONE', #704, #703);
 #706 = DIRECTION('NONE', (0, 0, -1));
 #707 = VECTOR('NONE', #706, 1);
-#708 = CARTESIAN_POINT('NONE', (-0.008801100000000001, 0.034925000000000005, 0.0206375));
+#708 = CARTESIAN_POINT('NONE', (-0.008801100000000003, 0.034925000000000005, 0.0206375));
 #709 = LINE('NONE', #708, #707);
-#710 = DIRECTION('NONE', (-0.49999999999999944, 0.866025403784439, 0));
+#710 = DIRECTION('NONE', (-0.49999999999999956, 0.8660254037844389, 0));
 #711 = VECTOR('NONE', #710, 1);
 #712 = CARTESIAN_POINT('NONE', (-0.004400550000000005, 0.027303023818752777, 0.0142875));
 #713 = LINE('NONE', #712, #711);
 #714 = DIRECTION('NONE', (0.5000000000000002, 0.8660254037844386, 0));
 #715 = VECTOR('NONE', #714, 1);
-#716 = CARTESIAN_POINT('NONE', (-0.008801100000000001, 0.034925000000000005, 0.0206375));
+#716 = CARTESIAN_POINT('NONE', (-0.008801100000000003, 0.034925000000000005, 0.0206375));
 #717 = LINE('NONE', #716, #715);
 #718 = DIRECTION('NONE', (0, 0, -1));
 #719 = VECTOR('NONE', #718, 1);
-#720 = CARTESIAN_POINT('NONE', (-0.00440055, 0.042546976181247226, 0.0206375));
+#720 = CARTESIAN_POINT('NONE', (-0.004400550000000001, 0.042546976181247226, 0.0206375));
 #721 = LINE('NONE', #720, #719);
 #722 = DIRECTION('NONE', (0.5000000000000002, 0.8660254037844386, 0));
 #723 = VECTOR('NONE', #722, 1);
-#724 = CARTESIAN_POINT('NONE', (-0.008801100000000001, 0.034925000000000005, 0.0142875));
+#724 = CARTESIAN_POINT('NONE', (-0.008801100000000003, 0.034925000000000005, 0.0142875));
 #725 = LINE('NONE', #724, #723);
 #726 = DIRECTION('NONE', (1, 0, 0));
 #727 = VECTOR('NONE', #726, 1);
-#728 = CARTESIAN_POINT('NONE', (-0.00440055, 0.042546976181247226, 0.0206375));
+#728 = CARTESIAN_POINT('NONE', (-0.004400550000000001, 0.042546976181247226, 0.0206375));
 #729 = LINE('NONE', #728, #727);
 #730 = DIRECTION('NONE', (0, 0, -1));
 #731 = VECTOR('NONE', #730, 1);
-#732 = CARTESIAN_POINT('NONE', (0.004400550000000001, 0.042546976181247226, 0.0206375));
+#732 = CARTESIAN_POINT('NONE', (0.00440055, 0.042546976181247226, 0.0206375));
 #733 = LINE('NONE', #732, #731);
 #734 = DIRECTION('NONE', (1, 0, 0));
 #735 = VECTOR('NONE', #734, 1);
-#736 = CARTESIAN_POINT('NONE', (-0.00440055, 0.042546976181247226, 0.0142875));
+#736 = CARTESIAN_POINT('NONE', (-0.004400550000000001, 0.042546976181247226, 0.0142875));
 #737 = LINE('NONE', #736, #735);
-#738 = DIRECTION('NONE', (0.4999999999999997, -0.8660254037844388, 0));
+#738 = DIRECTION('NONE', (0.4999999999999999, -0.8660254037844388, 0));
 #739 = VECTOR('NONE', #738, 1);
-#740 = CARTESIAN_POINT('NONE', (0.004400550000000001, 0.042546976181247226, 0.0206375));
+#740 = CARTESIAN_POINT('NONE', (0.00440055, 0.042546976181247226, 0.0206375));
 #741 = LINE('NONE', #740, #739);
-#742 = DIRECTION('NONE', (0.4999999999999997, -0.8660254037844388, 0));
+#742 = DIRECTION('NONE', (0.4999999999999999, -0.8660254037844388, 0));
 #743 = VECTOR('NONE', #742, 1);
-#744 = CARTESIAN_POINT('NONE', (0.004400550000000001, 0.042546976181247226, 0.0142875));
+#744 = CARTESIAN_POINT('NONE', (0.00440055, 0.042546976181247226, 0.0142875));
 #745 = LINE('NONE', #744, #743);
 #746 = DIRECTION('NONE', (-0.0000000000000002449293598294707, 1, -0));
 #747 = DIRECTION('NONE', (-0, 0, 1));
@@ -801,49 +801,49 @@ DATA;
 #785 = VECTOR('NONE', #784, 1);
 #786 = CARTESIAN_POINT('NONE', (0.024090061635644863, 0.013582668380723768, 0.0142875));
 #787 = LINE('NONE', #786, #785);
-#788 = DIRECTION('NONE', (0.3653410243663952, 0.9308737486442042, 0));
+#788 = DIRECTION('NONE', (0.3653410243663951, 0.9308737486442044, 0));
 #789 = VECTOR('NONE', #788, 1);
 #790 = CARTESIAN_POINT('NONE', (0.01860266554050596, 0.020463645441073146, 0.0206375));
 #791 = LINE('NONE', #790, #789);
 #792 = DIRECTION('NONE', (0, 0, -1));
 #793 = VECTOR('NONE', #792, 1);
-#794 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265653, 0.0206375));
+#794 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265656, 0.0206375));
 #795 = LINE('NONE', #794, #793);
-#796 = DIRECTION('NONE', (0.3653410243663952, 0.9308737486442042, 0));
+#796 = DIRECTION('NONE', (0.3653410243663951, 0.9308737486442044, 0));
 #797 = VECTOR('NONE', #796, 1);
 #798 = CARTESIAN_POINT('NONE', (0.01860266554050596, 0.020463645441073146, 0.0142875));
 #799 = LINE('NONE', #798, #797);
-#800 = DIRECTION('NONE', (0.9888308262251287, 0.14904226617617372, 0));
+#800 = DIRECTION('NONE', (0.9888308262251287, 0.1490422661761738, 0));
 #801 = VECTOR('NONE', #800, 1);
-#802 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265653, 0.0206375));
+#802 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265656, 0.0206375));
 #803 = LINE('NONE', #802, #801);
 #804 = DIRECTION('NONE', (0, 0, -1));
 #805 = VECTOR('NONE', #804, 1);
-#806 = CARTESIAN_POINT('NONE', (0.030520867414747018, 0.029968094279108775, 0.0206375));
+#806 = CARTESIAN_POINT('NONE', (0.030520867414747015, 0.02996809427910878, 0.0206375));
 #807 = LINE('NONE', #806, #805);
-#808 = DIRECTION('NONE', (0.9888308262251287, 0.14904226617617372, 0));
+#808 = DIRECTION('NONE', (0.9888308262251287, 0.1490422661761738, 0));
 #809 = VECTOR('NONE', #808, 1);
-#810 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265653, 0.0142875));
+#810 = CARTESIAN_POINT('NONE', (0.02181806843005704, 0.028656358390265656, 0.0142875));
 #811 = LINE('NONE', #810, #809);
-#812 = DIRECTION('NONE', (0.6234898018587341, -0.7818314824680294, 0));
+#812 = DIRECTION('NONE', (0.6234898018587344, -0.7818314824680292, 0));
 #813 = VECTOR('NONE', #812, 1);
-#814 = CARTESIAN_POINT('NONE', (0.030520867414747018, 0.029968094279108775, 0.0206375));
+#814 = CARTESIAN_POINT('NONE', (0.030520867414747015, 0.02996809427910878, 0.0206375));
 #815 = LINE('NONE', #814, #813);
 #816 = DIRECTION('NONE', (0, 0, -1));
 #817 = VECTOR('NONE', #816, 1);
-#818 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.0230871172187594, 0.0206375));
+#818 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.023087117218759404, 0.0206375));
 #819 = LINE('NONE', #818, #817);
-#820 = DIRECTION('NONE', (0.6234898018587341, -0.7818314824680294, 0));
+#820 = DIRECTION('NONE', (0.6234898018587344, -0.7818314824680292, 0));
 #821 = VECTOR('NONE', #820, 1);
-#822 = CARTESIAN_POINT('NONE', (0.030520867414747018, 0.029968094279108775, 0.0142875));
+#822 = CARTESIAN_POINT('NONE', (0.030520867414747015, 0.02996809427910878, 0.0142875));
 #823 = LINE('NONE', #822, #821);
-#824 = DIRECTION('NONE', (-0.36534102436639604, -0.9308737486442038, 0));
+#824 = DIRECTION('NONE', (-0.36534102436639593, -0.9308737486442038, 0));
 #825 = VECTOR('NONE', #824, 1);
-#826 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.0230871172187594, 0.0206375));
+#826 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.023087117218759404, 0.0206375));
 #827 = LINE('NONE', #826, #825);
-#828 = DIRECTION('NONE', (-0.36534102436639604, -0.9308737486442038, 0));
+#828 = DIRECTION('NONE', (-0.36534102436639593, -0.9308737486442038, 0));
 #829 = VECTOR('NONE', #828, 1);
-#830 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.0230871172187594, 0.0142875));
+#830 = CARTESIAN_POINT('NONE', (0.036008263509885924, 0.023087117218759404, 0.0142875));
 #831 = LINE('NONE', #830, #829);
 #832 = DIRECTION('NONE', (0.78183148246803, 0.6234898018587336, -0));
 #833 = DIRECTION('NONE', (0, 0, 1.0000000000000002));
@@ -887,41 +887,41 @@ DATA;
 #871 = VECTOR('NONE', #870, 1);
 #872 = CARTESIAN_POINT('NONE', (0.025639265511945786, -0.010365713383932086, 0.0142875));
 #873 = LINE('NONE', #872, #871);
-#874 = DIRECTION('NONE', (0.955572805786141, 0.2947551744109036, 0));
+#874 = DIRECTION('NONE', (0.9555728057861409, 0.29475517441090376, 0));
 #875 = VECTOR('NONE', #874, 1);
 #876 = CARTESIAN_POINT('NONE', (0.027597694503788704, -0.0017852753360286355, 0.0206375));
 #877 = LINE('NONE', #876, #875);
 #878 = DIRECTION('NONE', (0, 0, -1));
 #879 = VECTOR('NONE', #878, 1);
-#880 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.00080889442947917, 0.0206375));
+#880 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.0008088944294791717, 0.0206375));
 #881 = LINE('NONE', #880, #879);
-#882 = DIRECTION('NONE', (0.955572805786141, 0.2947551744109036, 0));
+#882 = DIRECTION('NONE', (0.9555728057861409, 0.29475517441090376, 0));
 #883 = VECTOR('NONE', #882, 1);
 #884 = CARTESIAN_POINT('NONE', (0.027597694503788704, -0.0017852753360286355, 0.0142875));
 #885 = LINE('NONE', #884, #883);
 #886 = DIRECTION('NONE', (0.7330518718298261, -0.6801727377709197, 0));
 #887 = VECTOR('NONE', #886, 1);
-#888 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.00080889442947917, 0.0206375));
+#888 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.0008088944294791717, 0.0206375));
 #889 = LINE('NONE', #888, #887);
 #890 = DIRECTION('NONE', (0, 0, -1));
 #891 = VECTOR('NONE', #890, 1);
-#892 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.005177373852916468, 0.0206375));
+#892 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.0051773738529164665, 0.0206375));
 #893 = LINE('NONE', #892, #891);
 #894 = DIRECTION('NONE', (0.7330518718298261, -0.6801727377709197, 0));
 #895 = VECTOR('NONE', #894, 1);
-#896 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.00080889442947917, 0.0142875));
+#896 = CARTESIAN_POINT('NONE', (0.036007786324793116, 0.0008088944294791717, 0.0142875));
 #897 = LINE('NONE', #896, #895);
-#898 = DIRECTION('NONE', (-0.22252093395631514, -0.9749279121818235, 0));
+#898 = DIRECTION('NONE', (-0.22252093395631506, -0.9749279121818235, 0));
 #899 = VECTOR('NONE', #898, 1);
-#900 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.005177373852916468, 0.0206375));
+#900 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.0051773738529164665, 0.0206375));
 #901 = LINE('NONE', #900, #899);
 #902 = DIRECTION('NONE', (0, 0, -1));
 #903 = VECTOR('NONE', #902, 1);
 #904 = CARTESIAN_POINT('NONE', (0.04050102016211167, -0.013757811900819917, 0.0206375));
 #905 = LINE('NONE', #904, #903);
-#906 = DIRECTION('NONE', (-0.22252093395631514, -0.9749279121818235, 0));
+#906 = DIRECTION('NONE', (-0.22252093395631506, -0.9749279121818235, 0));
 #907 = VECTOR('NONE', #906, 1);
-#908 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.005177373852916468, 0.0142875));
+#908 = CARTESIAN_POINT('NONE', (0.042459449153954595, -0.0051773738529164665, 0.0142875));
 #909 = LINE('NONE', #908, #907);
 #910 = DIRECTION('NONE', (-0.9555728057861407, -0.2947551744109045, 0));
 #911 = VECTOR('NONE', #910, 1);
@@ -973,49 +973,49 @@ DATA;
 #957 = VECTOR('NONE', #956, 1);
 #958 = CARTESIAN_POINT('NONE', (0.007881579512048221, -0.02650850154846824, 0.0142875));
 #959 = LINE('NONE', #958, #957);
-#960 = DIRECTION('NONE', (0.8262387743159946, -0.5633200580636225, 0));
+#960 = DIRECTION('NONE', (0.8262387743159947, -0.5633200580636224, 0));
 #961 = VECTOR('NONE', #960, 1);
 #962 = CARTESIAN_POINT('NONE', (0.015811096615344203, -0.022689847372120698, 0.0206375));
 #963 = LINE('NONE', #962, #961);
 #964 = DIRECTION('NONE', (0, 0, -1));
 #965 = VECTOR('NONE', #964, 1);
-#966 = CARTESIAN_POINT('NONE', (0.023082906691976702, -0.027647683535144445, 0.0206375));
+#966 = CARTESIAN_POINT('NONE', (0.023082906691976705, -0.027647683535144445, 0.0206375));
 #967 = LINE('NONE', #966, #965);
-#968 = DIRECTION('NONE', (0.8262387743159946, -0.5633200580636225, 0));
+#968 = DIRECTION('NONE', (0.8262387743159947, -0.5633200580636224, 0));
 #969 = VECTOR('NONE', #968, 1);
 #970 = CARTESIAN_POINT('NONE', (0.015811096615344203, -0.022689847372120698, 0.0142875));
 #971 = LINE('NONE', #970, #969);
 #972 = DIRECTION('NONE', (-0.07473009358642455, -0.9972037971811801, 0));
 #973 = VECTOR('NONE', #972, 1);
-#974 = CARTESIAN_POINT('NONE', (0.023082906691976702, -0.027647683535144445, 0.0206375));
+#974 = CARTESIAN_POINT('NONE', (0.023082906691976705, -0.027647683535144445, 0.0206375));
 #975 = LINE('NONE', #974, #973);
 #976 = DIRECTION('NONE', (0, 0, -1));
 #977 = VECTOR('NONE', #976, 1);
-#978 = CARTESIAN_POINT('NONE', (0.02242519966531322, -0.03642417387451573, 0.0206375));
+#978 = CARTESIAN_POINT('NONE', (0.022425199665313224, -0.03642417387451573, 0.0206375));
 #979 = LINE('NONE', #978, #977);
 #980 = DIRECTION('NONE', (-0.07473009358642455, -0.9972037971811801, 0));
 #981 = VECTOR('NONE', #980, 1);
-#982 = CARTESIAN_POINT('NONE', (0.023082906691976702, -0.027647683535144445, 0.0142875));
+#982 = CARTESIAN_POINT('NONE', (0.023082906691976705, -0.027647683535144445, 0.0142875));
 #983 = LINE('NONE', #982, #981);
-#984 = DIRECTION('NONE', (-0.9009688679024193, -0.43388373911755806, 0));
+#984 = DIRECTION('NONE', (-0.9009688679024193, -0.43388373911755795, 0));
 #985 = VECTOR('NONE', #984, 1);
-#986 = CARTESIAN_POINT('NONE', (0.02242519966531322, -0.03642417387451573, 0.0206375));
+#986 = CARTESIAN_POINT('NONE', (0.022425199665313224, -0.03642417387451573, 0.0206375));
 #987 = LINE('NONE', #986, #985);
 #988 = DIRECTION('NONE', (0, 0, -1));
 #989 = VECTOR('NONE', #988, 1);
-#990 = CARTESIAN_POINT('NONE', (0.014495682562017243, -0.040242828050863266, 0.0206375));
+#990 = CARTESIAN_POINT('NONE', (0.014495682562017245, -0.040242828050863266, 0.0206375));
 #991 = LINE('NONE', #990, #989);
-#992 = DIRECTION('NONE', (-0.9009688679024193, -0.43388373911755806, 0));
+#992 = DIRECTION('NONE', (-0.9009688679024193, -0.43388373911755795, 0));
 #993 = VECTOR('NONE', #992, 1);
-#994 = CARTESIAN_POINT('NONE', (0.02242519966531322, -0.03642417387451573, 0.0142875));
+#994 = CARTESIAN_POINT('NONE', (0.022425199665313224, -0.03642417387451573, 0.0142875));
 #995 = LINE('NONE', #994, #993);
-#996 = DIRECTION('NONE', (-0.8262387743159952, 0.5633200580636217, 0));
+#996 = DIRECTION('NONE', (-0.8262387743159951, 0.5633200580636216, 0));
 #997 = VECTOR('NONE', #996, 1);
-#998 = CARTESIAN_POINT('NONE', (0.014495682562017243, -0.040242828050863266, 0.0206375));
+#998 = CARTESIAN_POINT('NONE', (0.014495682562017245, -0.040242828050863266, 0.0206375));
 #999 = LINE('NONE', #998, #997);
-#1000 = DIRECTION('NONE', (-0.8262387743159952, 0.5633200580636217, 0));
+#1000 = DIRECTION('NONE', (-0.8262387743159951, 0.5633200580636216, 0));
 #1001 = VECTOR('NONE', #1000, 1);
-#1002 = CARTESIAN_POINT('NONE', (0.014495682562017243, -0.040242828050863266, 0.0142875));
+#1002 = CARTESIAN_POINT('NONE', (0.014495682562017245, -0.040242828050863266, 0.0142875));
 #1003 = LINE('NONE', #1002, #1001);
 #1004 = DIRECTION('NONE', (0.4338837391175578, -0.9009688679024195, -0));
 #1005 = DIRECTION('NONE', (0, 0, 1.0000000000000002));
@@ -1059,49 +1059,49 @@ DATA;
 #1043 = VECTOR('NONE', #1042, 1);
 #1044 = CARTESIAN_POINT('NONE', (-0.015811096615344192, -0.022689847372120705, 0.014287499999999998));
 #1045 = LINE('NONE', #1044, #1043);
-#1046 = DIRECTION('NONE', (0.07473009358642402, -0.9972037971811802, 0));
+#1046 = DIRECTION('NONE', (0.07473009358642413, -0.9972037971811802, 0));
 #1047 = VECTOR('NONE', #1046, 1);
 #1048 = CARTESIAN_POINT('NONE', (-0.007881579512048209, -0.026508501548468247, 0.020637499999999996));
 #1049 = LINE('NONE', #1048, #1047);
 #1050 = DIRECTION('NONE', (0, 0, -1));
 #1051 = VECTOR('NONE', #1050, 1);
-#1052 = CARTESIAN_POINT('NONE', (-0.0072238724853847325, -0.03528499188783953, 0.020637499999999996));
+#1052 = CARTESIAN_POINT('NONE', (-0.007223872485384732, -0.03528499188783953, 0.020637499999999996));
 #1053 = LINE('NONE', #1052, #1051);
-#1054 = DIRECTION('NONE', (0.07473009358642402, -0.9972037971811802, 0));
+#1054 = DIRECTION('NONE', (0.07473009358642413, -0.9972037971811802, 0));
 #1055 = VECTOR('NONE', #1054, 1);
 #1056 = CARTESIAN_POINT('NONE', (-0.007881579512048209, -0.026508501548468247, 0.014287499999999998));
 #1057 = LINE('NONE', #1056, #1055);
-#1058 = DIRECTION('NONE', (-0.826238774315995, -0.5633200580636218, 0));
+#1058 = DIRECTION('NONE', (-0.826238774315995, -0.563320058063622, 0));
 #1059 = VECTOR('NONE', #1058, 1);
-#1060 = CARTESIAN_POINT('NONE', (-0.0072238724853847325, -0.03528499188783953, 0.020637499999999996));
+#1060 = CARTESIAN_POINT('NONE', (-0.007223872485384732, -0.03528499188783953, 0.020637499999999996));
 #1061 = LINE('NONE', #1060, #1059);
 #1062 = DIRECTION('NONE', (0, 0, -1));
 #1063 = VECTOR('NONE', #1062, 1);
-#1064 = CARTESIAN_POINT('NONE', (-0.014495682562017234, -0.04024282805086327, 0.020637499999999996));
+#1064 = CARTESIAN_POINT('NONE', (-0.014495682562017232, -0.04024282805086327, 0.020637499999999996));
 #1065 = LINE('NONE', #1064, #1063);
-#1066 = DIRECTION('NONE', (-0.826238774315995, -0.5633200580636218, 0));
+#1066 = DIRECTION('NONE', (-0.826238774315995, -0.563320058063622, 0));
 #1067 = VECTOR('NONE', #1066, 1);
-#1068 = CARTESIAN_POINT('NONE', (-0.0072238724853847325, -0.03528499188783953, 0.014287499999999998));
+#1068 = CARTESIAN_POINT('NONE', (-0.007223872485384732, -0.03528499188783953, 0.014287499999999998));
 #1069 = LINE('NONE', #1068, #1067);
-#1070 = DIRECTION('NONE', (-0.9009688679024193, 0.4338837391175578, 0));
+#1070 = DIRECTION('NONE', (-0.9009688679024194, 0.4338837391175579, 0));
 #1071 = VECTOR('NONE', #1070, 1);
-#1072 = CARTESIAN_POINT('NONE', (-0.014495682562017234, -0.04024282805086327, 0.020637499999999996));
+#1072 = CARTESIAN_POINT('NONE', (-0.014495682562017232, -0.04024282805086327, 0.020637499999999996));
 #1073 = LINE('NONE', #1072, #1071);
 #1074 = DIRECTION('NONE', (0, 0, -1));
 #1075 = VECTOR('NONE', #1074, 1);
-#1076 = CARTESIAN_POINT('NONE', (-0.022425199665313218, -0.036424173874515735, 0.020637499999999996));
+#1076 = CARTESIAN_POINT('NONE', (-0.022425199665313214, -0.036424173874515735, 0.020637499999999996));
 #1077 = LINE('NONE', #1076, #1075);
-#1078 = DIRECTION('NONE', (-0.9009688679024193, 0.4338837391175578, 0));
+#1078 = DIRECTION('NONE', (-0.9009688679024194, 0.4338837391175579, 0));
 #1079 = VECTOR('NONE', #1078, 1);
-#1080 = CARTESIAN_POINT('NONE', (-0.014495682562017234, -0.04024282805086327, 0.014287499999999998));
+#1080 = CARTESIAN_POINT('NONE', (-0.014495682562017232, -0.04024282805086327, 0.014287499999999998));
 #1081 = LINE('NONE', #1080, #1079);
-#1082 = DIRECTION('NONE', (-0.07473009358642409, 0.9972037971811802, 0));
+#1082 = DIRECTION('NONE', (-0.07473009358642449, 0.9972037971811801, 0));
 #1083 = VECTOR('NONE', #1082, 1);
-#1084 = CARTESIAN_POINT('NONE', (-0.022425199665313218, -0.036424173874515735, 0.020637499999999996));
+#1084 = CARTESIAN_POINT('NONE', (-0.022425199665313214, -0.036424173874515735, 0.020637499999999996));
 #1085 = LINE('NONE', #1084, #1083);
-#1086 = DIRECTION('NONE', (-0.07473009358642409, 0.9972037971811802, 0));
+#1086 = DIRECTION('NONE', (-0.07473009358642449, 0.9972037971811801, 0));
 #1087 = VECTOR('NONE', #1086, 1);
-#1088 = CARTESIAN_POINT('NONE', (-0.022425199665313218, -0.036424173874515735, 0.014287499999999998));
+#1088 = CARTESIAN_POINT('NONE', (-0.022425199665313214, -0.036424173874515735, 0.014287499999999998));
 #1089 = LINE('NONE', #1088, #1087);
 #1090 = DIRECTION('NONE', (-0.43388373911755884, -0.9009688679024187, -0));
 #1091 = DIRECTION('NONE', (0, -0, 0.9999999999999999));
@@ -1157,37 +1157,37 @@ DATA;
 #1141 = VECTOR('NONE', #1140, 1);
 #1142 = CARTESIAN_POINT('NONE', (-0.02563926551194579, -0.010365713383932076, 0.0142875));
 #1143 = LINE('NONE', #1142, #1141);
-#1144 = DIRECTION('NONE', (-0.9555728057861403, 0.29475517441090565, 0));
+#1144 = DIRECTION('NONE', (-0.9555728057861405, 0.29475517441090526, 0));
 #1145 = VECTOR('NONE', #1144, 1);
 #1146 = CARTESIAN_POINT('NONE', (-0.032090928341107286, -0.01635198166632771, 0.0206375));
 #1147 = LINE('NONE', #1146, #1145);
 #1148 = DIRECTION('NONE', (0, 0, -1));
 #1149 = VECTOR('NONE', #1148, 1);
-#1150 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.01375781190081989, 0.0206375));
+#1150 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.013757811900819893, 0.0206375));
 #1151 = LINE('NONE', #1150, #1149);
-#1152 = DIRECTION('NONE', (-0.9555728057861403, 0.29475517441090565, 0));
+#1152 = DIRECTION('NONE', (-0.9555728057861405, 0.29475517441090526, 0));
 #1153 = VECTOR('NONE', #1152, 1);
 #1154 = CARTESIAN_POINT('NONE', (-0.032090928341107286, -0.01635198166632771, 0.0142875));
 #1155 = LINE('NONE', #1154, #1153);
 #1156 = DIRECTION('NONE', (-0.22252093395631356, 0.9749279121818238, 0));
 #1157 = VECTOR('NONE', #1156, 1);
-#1158 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.01375781190081989, 0.0206375));
+#1158 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.013757811900819893, 0.0206375));
 #1159 = LINE('NONE', #1158, #1157);
 #1160 = DIRECTION('NONE', (0, 0, -1));
 #1161 = VECTOR('NONE', #1160, 1);
-#1162 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.005177373852916439, 0.0206375));
+#1162 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.0051773738529164405, 0.0206375));
 #1163 = LINE('NONE', #1162, #1161);
 #1164 = DIRECTION('NONE', (-0.22252093395631356, 0.9749279121818238, 0));
 #1165 = VECTOR('NONE', #1164, 1);
-#1166 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.01375781190081989, 0.0142875));
+#1166 = CARTESIAN_POINT('NONE', (-0.040501020162111684, -0.013757811900819893, 0.0142875));
 #1167 = LINE('NONE', #1166, #1165);
-#1168 = DIRECTION('NONE', (0.7330518718298267, 0.680172737770919, 0));
+#1168 = DIRECTION('NONE', (0.7330518718298267, 0.6801727377709191, 0));
 #1169 = VECTOR('NONE', #1168, 1);
-#1170 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.005177373852916439, 0.0206375));
+#1170 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.0051773738529164405, 0.0206375));
 #1171 = LINE('NONE', #1170, #1169);
-#1172 = DIRECTION('NONE', (0.7330518718298267, 0.680172737770919, 0));
+#1172 = DIRECTION('NONE', (0.7330518718298267, 0.6801727377709191, 0));
 #1173 = VECTOR('NONE', #1172, 1);
-#1174 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.005177373852916439, 0.0142875));
+#1174 = CARTESIAN_POINT('NONE', (-0.042459449153954595, -0.0051773738529164405, 0.0142875));
 #1175 = LINE('NONE', #1174, #1173);
 #1176 = DIRECTION('NONE', (-0.9749279121818236, -0.22252093395631475, -0));
 #1177 = DIRECTION('NONE', (0, -0, 1.0000000000000002));
@@ -1243,29 +1243,29 @@ DATA;
 #1227 = VECTOR('NONE', #1226, 1);
 #1228 = CARTESIAN_POINT('NONE', (-0.02409006163564487, 0.013582668380723755, 0.0142875));
 #1229 = LINE('NONE', #1228, #1227);
-#1230 = DIRECTION('NONE', (-0.36534102436639493, 0.9308737486442044, 0));
+#1230 = DIRECTION('NONE', (-0.3653410243663956, 0.930873748644204, 0));
 #1231 = VECTOR('NONE', #1230, 1);
 #1232 = CARTESIAN_POINT('NONE', (-0.032792860620334846, 0.014894404269566884, 0.0206375));
 #1233 = LINE('NONE', #1232, #1231);
 #1234 = DIRECTION('NONE', (0, 0, -1));
 #1235 = VECTOR('NONE', #1234, 1);
-#1236 = CARTESIAN_POINT('NONE', (-0.036008263509885924, 0.02308711721875939, 0.0206375));
+#1236 = CARTESIAN_POINT('NONE', (-0.03600826350988593, 0.02308711721875939, 0.0206375));
 #1237 = LINE('NONE', #1236, #1235);
-#1238 = DIRECTION('NONE', (-0.36534102436639493, 0.9308737486442044, 0));
+#1238 = DIRECTION('NONE', (-0.3653410243663956, 0.930873748644204, 0));
 #1239 = VECTOR('NONE', #1238, 1);
 #1240 = CARTESIAN_POINT('NONE', (-0.032792860620334846, 0.014894404269566884, 0.0142875));
 #1241 = LINE('NONE', #1240, #1239);
-#1242 = DIRECTION('NONE', (0.6234898018587333, 0.7818314824680301, 0));
+#1242 = DIRECTION('NONE', (0.6234898018587336, 0.7818314824680297, 0));
 #1243 = VECTOR('NONE', #1242, 1);
-#1244 = CARTESIAN_POINT('NONE', (-0.036008263509885924, 0.02308711721875939, 0.0206375));
+#1244 = CARTESIAN_POINT('NONE', (-0.03600826350988593, 0.02308711721875939, 0.0206375));
 #1245 = LINE('NONE', #1244, #1243);
 #1246 = DIRECTION('NONE', (0, 0, -1));
 #1247 = VECTOR('NONE', #1246, 1);
 #1248 = CARTESIAN_POINT('NONE', (-0.03052086741474703, 0.029968094279108768, 0.0206375));
 #1249 = LINE('NONE', #1248, #1247);
-#1250 = DIRECTION('NONE', (0.6234898018587333, 0.7818314824680301, 0));
+#1250 = DIRECTION('NONE', (0.6234898018587336, 0.7818314824680297, 0));
 #1251 = VECTOR('NONE', #1250, 1);
-#1252 = CARTESIAN_POINT('NONE', (-0.036008263509885924, 0.02308711721875939, 0.0142875));
+#1252 = CARTESIAN_POINT('NONE', (-0.03600826350988593, 0.02308711721875939, 0.0142875));
 #1253 = LINE('NONE', #1252, #1251);
 #1254 = DIRECTION('NONE', (0.9888308262251286, -0.14904226617617397, 0));
 #1255 = VECTOR('NONE', #1254, 1);
@@ -3385,20 +3385,20 @@ DATA;
 #3369 = DIRECTION('NONE', (-0, -1, 0));
 #3370 = AXIS2_PLACEMENT_3D('NONE', #3368, #3369, $);
 #3371 = PLANE('NONE', #3370);
-#3372 = CARTESIAN_POINT('NONE', (-0.006600825000000002, 0.031114011909376384, 0.0174625));
-#3373 = DIRECTION('NONE', (-0.866025403784439, -0.49999999999999956, -0.000000000000000000000000000000006162975822039155));
+#3372 = CARTESIAN_POINT('NONE', (-0.006600825000000004, 0.031114011909376387, 0.0174625));
+#3373 = DIRECTION('NONE', (-0.8660254037844388, -0.49999999999999967, -0));
 #3374 = AXIS2_PLACEMENT_3D('NONE', #3372, #3373, $);
 #3375 = PLANE('NONE', #3374);
-#3376 = CARTESIAN_POINT('NONE', (-0.006600824999999999, 0.038735988090623605, 0.0174625));
-#3377 = DIRECTION('NONE', (-0.8660254037844386, 0.5000000000000001, 0));
+#3376 = CARTESIAN_POINT('NONE', (-0.006600825000000002, 0.038735988090623605, 0.017462499999999995));
+#3377 = DIRECTION('NONE', (-0.8660254037844386, 0.5000000000000001, -0));
 #3378 = AXIS2_PLACEMENT_3D('NONE', #3376, #3377, $);
 #3379 = PLANE('NONE', #3378);
-#3380 = CARTESIAN_POINT('NONE', (0.000000000000000003996802888650563, 0.04254697618124722, 0.017462499999999995));
+#3380 = CARTESIAN_POINT('NONE', (-0.0000000000000000008881784197001253, 0.04254697618124722, 0.0174625));
 #3381 = DIRECTION('NONE', (0, 1, 0));
 #3382 = AXIS2_PLACEMENT_3D('NONE', #3380, #3381, $);
 #3383 = PLANE('NONE', #3382);
-#3384 = CARTESIAN_POINT('NONE', (0.006600825, 0.0387359880906236, 0.0174625));
-#3385 = DIRECTION('NONE', (0.8660254037844388, 0.4999999999999995, 0));
+#3384 = CARTESIAN_POINT('NONE', (0.0066008249999999985, 0.0387359880906236, 0.0174625));
+#3385 = DIRECTION('NONE', (0.8660254037844388, 0.49999999999999967, 0));
 #3386 = AXIS2_PLACEMENT_3D('NONE', #3384, #3385, $);
 #3387 = PLANE('NONE', #3386);
 #3388 = CARTESIAN_POINT('NONE', (0, 0.034925, 0.0174625));
@@ -3422,20 +3422,20 @@ DATA;
 #3406 = DIRECTION('NONE', (-0.7818314824680298, -0.6234898018587336, 0));
 #3407 = AXIS2_PLACEMENT_3D('NONE', #3405, #3406, $);
 #3408 = PLANE('NONE', #3407);
-#3409 = CARTESIAN_POINT('NONE', (0.020210366985281496, 0.024560001915669396, 0.0174625));
-#3410 = DIRECTION('NONE', (-0.9308737486442041, 0.36534102436639554, -0.000000000000000000000000000000006162975822039155));
+#3409 = CARTESIAN_POINT('NONE', (0.020210366985281496, 0.0245600019156694, 0.0174625));
+#3410 = DIRECTION('NONE', (-0.9308737486442044, 0.36534102436639515, -0));
 #3411 = AXIS2_PLACEMENT_3D('NONE', #3409, #3410, $);
 #3412 = PLANE('NONE', #3411);
-#3413 = CARTESIAN_POINT('NONE', (0.026169467922402028, 0.02931222633468721, 0.0174625));
-#3414 = DIRECTION('NONE', (-0.1490422661761737, 0.9888308262251286, 0));
+#3413 = CARTESIAN_POINT('NONE', (0.026169467922402025, 0.02931222633468721, 0.017462499999999995));
+#3414 = DIRECTION('NONE', (-0.14904226617617383, 0.9888308262251286, -0));
 #3415 = AXIS2_PLACEMENT_3D('NONE', #3413, #3414, $);
 #3416 = PLANE('NONE', #3415);
-#3417 = CARTESIAN_POINT('NONE', (0.03326456546231646, 0.026527605748934077, 0.017462499999999995));
-#3418 = DIRECTION('NONE', (0.7818314824680298, 0.6234898018587336, 0));
+#3417 = CARTESIAN_POINT('NONE', (0.03326456546231646, 0.026527605748934088, 0.0174625));
+#3418 = DIRECTION('NONE', (0.7818314824680295, 0.6234898018587338, 0));
 #3419 = AXIS2_PLACEMENT_3D('NONE', #3417, #3418, $);
 #3420 = PLANE('NONE', #3419);
 #3421 = CARTESIAN_POINT('NONE', (0.03440056206511037, 0.018990760744163143, 0.0174625));
-#3422 = DIRECTION('NONE', (0.9308737486442041, -0.3653410243663953, 0));
+#3422 = DIRECTION('NONE', (0.9308737486442044, -0.36534102436639526, 0));
 #3423 = AXIS2_PLACEMENT_3D('NONE', #3421, #3422, $);
 #3424 = PLANE('NONE', #3423);
 #3425 = CARTESIAN_POINT('NONE', (0.02730546452519594, 0.02177538132991627, 0.0174625));
@@ -3459,16 +3459,16 @@ DATA;
 #3443 = DIRECTION('NONE', (-0.9749279121818235, 0.22252093395631442, -0.0000000000000000000000000000000030814879110195774));
 #3444 = AXIS2_PLACEMENT_3D('NONE', #3442, #3443, $);
 #3445 = PLANE('NONE', #3444);
-#3446 = CARTESIAN_POINT('NONE', (0.0318027404142909, -0.00048819045327473263, 0.0174625));
-#3447 = DIRECTION('NONE', (-0.2947551744109037, 0.955572805786141, -0.000000000000000000000000000000006162975822039155));
+#3446 = CARTESIAN_POINT('NONE', (0.03180274041429091, -0.0004881904532747314, 0.0174625));
+#3447 = DIRECTION('NONE', (-0.2947551744109037, 0.9555728057861408, -0));
 #3448 = AXIS2_PLACEMENT_3D('NONE', #3446, #3447, $);
 #3449 = PLANE('NONE', #3448);
-#3450 = CARTESIAN_POINT('NONE', (0.039233617739373845, -0.0021842397117186486, 0.0174625));
-#3451 = DIRECTION('NONE', (0.6801727377709197, 0.733051871829826, 0));
+#3450 = CARTESIAN_POINT('NONE', (0.039233617739373845, -0.002184239711718646, 0.017462499999999995));
+#3451 = DIRECTION('NONE', (0.6801727377709199, 0.7330518718298258, 0));
 #3452 = AXIS2_PLACEMENT_3D('NONE', #3450, #3451, $);
 #3453 = PLANE('NONE', #3452);
-#3454 = CARTESIAN_POINT('NONE', (0.041480234658033126, -0.009467592876868191, 0.017462499999999995));
-#3455 = DIRECTION('NONE', (0.9749279121818237, -0.22252093395631437, 0));
+#3454 = CARTESIAN_POINT('NONE', (0.041480234658033126, -0.00946759287686819, 0.0174625));
+#3455 = DIRECTION('NONE', (0.9749279121818235, -0.22252093395631442, 0));
 #3456 = AXIS2_PLACEMENT_3D('NONE', #3454, #3455, $);
 #3457 = PLANE('NONE', #3456);
 #3458 = CARTESIAN_POINT('NONE', (0.036295974251609464, -0.015054896783573819, 0.0174625));
@@ -3496,20 +3496,20 @@ DATA;
 #3480 = DIRECTION('NONE', (-0.43388373911755784, 0.9009688679024194, 0.000000000000000000000000000000006162975822039155));
 #3481 = AXIS2_PLACEMENT_3D('NONE', #3479, #3480, $);
 #3482 = PLANE('NONE', #3481);
-#3483 = CARTESIAN_POINT('NONE', (0.01944700165366045, -0.025168765453632568, 0.0174625));
-#3484 = DIRECTION('NONE', (0.5633200580636224, 0.8262387743159947, 0));
+#3483 = CARTESIAN_POINT('NONE', (0.01944700165366045, -0.02516876545363257, 0.0174625));
+#3484 = DIRECTION('NONE', (0.5633200580636222, 0.8262387743159947, 0));
 #3485 = AXIS2_PLACEMENT_3D('NONE', #3483, #3484, $);
 #3486 = PLANE('NONE', #3485);
-#3487 = CARTESIAN_POINT('NONE', (0.02275405317864496, -0.03203592870483008, 0.0174625));
-#3488 = DIRECTION('NONE', (0.9972037971811802, -0.07473009358642456, 0.0000000000000000000000000000000015407439555097887));
+#3487 = CARTESIAN_POINT('NONE', (0.022754053178644963, -0.032035928704830074, 0.017462499999999995));
+#3488 = DIRECTION('NONE', (0.9972037971811802, -0.07473009358642414, 0));
 #3489 = AXIS2_PLACEMENT_3D('NONE', #3487, #3488, $);
 #3490 = PLANE('NONE', #3489);
-#3491 = CARTESIAN_POINT('NONE', (0.018460441113665228, -0.03833350096268949, 0.017462499999999995));
-#3492 = DIRECTION('NONE', (0.43388373911755723, -0.9009688679024195, 0));
+#3491 = CARTESIAN_POINT('NONE', (0.018460441113665235, -0.03833350096268949, 0.0174625));
+#3492 = DIRECTION('NONE', (0.4338837391175577, -0.9009688679024195, 0));
 #3493 = AXIS2_PLACEMENT_3D('NONE', #3491, #3492, $);
 #3494 = PLANE('NONE', #3493);
 #3495 = CARTESIAN_POINT('NONE', (0.01085977752370099, -0.03776390996935139, 0.0174625));
-#3496 = DIRECTION('NONE', (-0.5633200580636213, -0.8262387743159954, -0));
+#3496 = DIRECTION('NONE', (-0.5633200580636212, -0.8262387743159955, -0));
 #3497 = AXIS2_PLACEMENT_3D('NONE', #3495, #3496, $);
 #3498 = PLANE('NONE', #3497);
 #3499 = CARTESIAN_POINT('NONE', (0.015153389588680722, -0.03146633771149198, 0.0174625));
@@ -3533,20 +3533,20 @@ DATA;
 #3517 = DIRECTION('NONE', (0.43388373911755823, 0.9009688679024191, 0));
 #3518 = AXIS2_PLACEMENT_3D('NONE', #3516, #3517, $);
 #3519 = PLANE('NONE', #3518);
-#3520 = CARTESIAN_POINT('NONE', (-0.00755272599871647, -0.030896746718153883, 0.017462499999999995));
-#3521 = DIRECTION('NONE', (0.9972037971811802, 0.074730093586424, 0));
+#3520 = CARTESIAN_POINT('NONE', (-0.007552725998716469, -0.030896746718153886, 0.017462499999999992));
+#3521 = DIRECTION('NONE', (0.9972037971811802, 0.07473009358642403, 0));
 #3522 = AXIS2_PLACEMENT_3D('NONE', #3520, #3521, $);
 #3523 = PLANE('NONE', #3522);
-#3524 = CARTESIAN_POINT('NONE', (-0.010859777523700983, -0.037763909969351396, 0.017462499999999995));
-#3525 = DIRECTION('NONE', (0.5633200580636216, -0.8262387743159952, 0));
+#3524 = CARTESIAN_POINT('NONE', (-0.01085977752370098, -0.037763909969351396, 0.017462499999999995));
+#3525 = DIRECTION('NONE', (0.563320058063622, -0.8262387743159951, 0));
 #3526 = AXIS2_PLACEMENT_3D('NONE', #3524, #3525, $);
 #3527 = PLANE('NONE', #3526);
-#3528 = CARTESIAN_POINT('NONE', (-0.018460441113665228, -0.03833350096268949, 0.017462499999999992));
-#3529 = DIRECTION('NONE', (-0.4338837391175573, -0.9009688679024197, -0));
+#3528 = CARTESIAN_POINT('NONE', (-0.018460441113665224, -0.0383335009626895, 0.017462499999999995));
+#3529 = DIRECTION('NONE', (-0.43388373911755745, -0.9009688679024194, 0.000000000000000000000000000000006162975822039155));
 #3530 = AXIS2_PLACEMENT_3D('NONE', #3528, #3529, $);
 #3531 = PLANE('NONE', #3530);
 #3532 = CARTESIAN_POINT('NONE', (-0.022754053178644953, -0.03203592870483008, 0.017462499999999995));
-#3533 = DIRECTION('NONE', (-0.9972037971811802, -0.07473009358642368, 0));
+#3533 = DIRECTION('NONE', (-0.9972037971811802, -0.07473009358642413, -0.0000000000000000000000000000000015407439555097887));
 #3534 = AXIS2_PLACEMENT_3D('NONE', #3532, #3533, $);
 #3535 = PLANE('NONE', #3534);
 #3536 = CARTESIAN_POINT('NONE', (-0.015153389588680708, -0.031466337711491994, 0.017462499999999995));
@@ -3570,20 +3570,20 @@ DATA;
 #3554 = DIRECTION('NONE', (0.9749279121818237, 0.22252093395631356, 0));
 #3555 = AXIS2_PLACEMENT_3D('NONE', #3553, #3554, $);
 #3556 = PLANE('NONE', #3555);
-#3557 = CARTESIAN_POINT('NONE', (-0.028865096926526532, -0.01335884752512989, 0.0174625));
-#3558 = DIRECTION('NONE', (0.6801727377709186, -0.7330518718298271, 0.000000000000000000000000000000006162975822039155));
+#3557 = CARTESIAN_POINT('NONE', (-0.028865096926526532, -0.013358847525129893, 0.0174625));
+#3558 = DIRECTION('NONE', (0.6801727377709185, -0.7330518718298272, 0));
 #3559 = AXIS2_PLACEMENT_3D('NONE', #3557, #3558, $);
 #3560 = PLANE('NONE', #3559);
-#3561 = CARTESIAN_POINT('NONE', (-0.03629597425160948, -0.015054896783573798, 0.0174625));
-#3562 = DIRECTION('NONE', (-0.2947551744109055, -0.9555728057861405, -0.000000000000000000000000000000006162975822039155));
+#3561 = CARTESIAN_POINT('NONE', (-0.03629597425160948, -0.0150548967835738, 0.017462499999999995));
+#3562 = DIRECTION('NONE', (-0.2947551744109054, -0.9555728057861405, -0));
 #3563 = AXIS2_PLACEMENT_3D('NONE', #3561, #3562, $);
 #3564 = PLANE('NONE', #3563);
-#3565 = CARTESIAN_POINT('NONE', (-0.041480234658033126, -0.009467592876868158, 0.017462499999999995));
-#3566 = DIRECTION('NONE', (-0.974927912181824, -0.22252093395631345, 0));
+#3565 = CARTESIAN_POINT('NONE', (-0.04148023465803313, -0.009467592876868165, 0.0174625));
+#3566 = DIRECTION('NONE', (-0.974927912181824, -0.2225209339563127, -0));
 #3567 = AXIS2_PLACEMENT_3D('NONE', #3565, #3566, $);
 #3568 = PLANE('NONE', #3567);
-#3569 = CARTESIAN_POINT('NONE', (-0.03923361773937384, -0.0021842397117186212, 0.0174625));
-#3570 = DIRECTION('NONE', (-0.6801727377709191, 0.7330518718298266, -0));
+#3569 = CARTESIAN_POINT('NONE', (-0.03923361773937384, -0.002184239711718622, 0.0174625));
+#3570 = DIRECTION('NONE', (-0.6801727377709194, 0.7330518718298266, -0));
 #3571 = AXIS2_PLACEMENT_3D('NONE', #3569, #3570, $);
 #3572 = PLANE('NONE', #3571);
 #3573 = CARTESIAN_POINT('NONE', (-0.0340493573329502, -0.007771543618424253, 0.0174625));
@@ -3608,15 +3608,15 @@ DATA;
 #3592 = AXIS2_PLACEMENT_3D('NONE', #3590, #3591, $);
 #3593 = PLANE('NONE', #3592);
 #3594 = CARTESIAN_POINT('NONE', (-0.028441461127989853, 0.014238536325145318, 0.0174625));
-#3595 = DIRECTION('NONE', (-0.1490422661761743, -0.9888308262251286, 0.0000000000000000000000000000000030814879110195774));
+#3595 = DIRECTION('NONE', (-0.14904226617617458, -0.9888308262251286, -0));
 #3596 = AXIS2_PLACEMENT_3D('NONE', #3594, #3595, $);
 #3597 = PLANE('NONE', #3596);
-#3598 = CARTESIAN_POINT('NONE', (-0.03440056206511038, 0.018990760744163133, 0.0174625));
-#3599 = DIRECTION('NONE', (-0.9308737486442047, -0.3653410243663939, 0));
+#3598 = CARTESIAN_POINT('NONE', (-0.03440056206511038, 0.018990760744163133, 0.017462499999999995));
+#3599 = DIRECTION('NONE', (-0.9308737486442044, -0.36534102436639526, -0));
 #3600 = AXIS2_PLACEMENT_3D('NONE', #3598, #3599, $);
 #3601 = PLANE('NONE', #3600);
-#3602 = CARTESIAN_POINT('NONE', (-0.03326456546231646, 0.026527605748934074, 0.017462499999999995));
-#3603 = DIRECTION('NONE', (-0.7818314824680305, 0.6234898018587326, -0.00000000000000000000000000000001232595164407831));
+#3602 = CARTESIAN_POINT('NONE', (-0.033264565462316466, 0.026527605748934074, 0.0174625));
+#3603 = DIRECTION('NONE', (-0.7818314824680298, 0.6234898018587336, -0));
 #3604 = AXIS2_PLACEMENT_3D('NONE', #3602, #3603, $);
 #3605 = PLANE('NONE', #3604);
 #3606 = CARTESIAN_POINT('NONE', (-0.02616946792240203, 0.029312226334687202, 0.0174625));

public/kcl-samples/step/walkie-talkie.step

@@ -2571,21 +2571,21 @@ DATA;
 #2555 = VERTEX_POINT('NONE', #2554);
 #2556 = CARTESIAN_POINT('NONE', (-0.007619999999999999, -0.04635499999999999, 0.0254));
 #2557 = VERTEX_POINT('NONE', #2556);
-#2558 = CARTESIAN_POINT('NONE', (0.0020980400000000002, -0.04167632, 0.0238125));
+#2558 = CARTESIAN_POINT('NONE', (0.0020980400000000007, -0.04167632, 0.0238125));
 #2559 = VERTEX_POINT('NONE', #2558);
-#2560 = CARTESIAN_POINT('NONE', (0.0012729244244215345, -0.0425658054737599, 0.0238125));
+#2560 = CARTESIAN_POINT('NONE', (0.0012729244244215347, -0.0425658054737599, 0.0238125));
 #2561 = VERTEX_POINT('NONE', #2560);
-#2562 = CARTESIAN_POINT('NONE', (0.0012729244244215345, -0.0425658054737599, 0.0254));
+#2562 = CARTESIAN_POINT('NONE', (0.0012729244244215347, -0.0425658054737599, 0.0254));
 #2563 = VERTEX_POINT('NONE', #2562);
-#2564 = CARTESIAN_POINT('NONE', (0.0020980400000000002, -0.04167632, 0.0254));
+#2564 = CARTESIAN_POINT('NONE', (0.0020980400000000007, -0.04167632, 0.0254));
 #2565 = VERTEX_POINT('NONE', #2564);
-#2566 = CARTESIAN_POINT('NONE', (-0.0006804866009285434, -0.0446716083246068, 0.0238125));
+#2566 = CARTESIAN_POINT('NONE', (-0.000680486600928543, -0.0446716083246068, 0.0238125));
 #2567 = VERTEX_POINT('NONE', #2566);
-#2568 = CARTESIAN_POINT('NONE', (-0.0006804866009285434, -0.0446716083246068, 0.0254));
+#2568 = CARTESIAN_POINT('NONE', (-0.000680486600928543, -0.0446716083246068, 0.0254));
 #2569 = VERTEX_POINT('NONE', #2568);
-#2570 = CARTESIAN_POINT('NONE', (-0.0015096417774425879, -0.045565448541457644, 0.0238125));
+#2570 = CARTESIAN_POINT('NONE', (-0.0015096417774425877, -0.045565448541457644, 0.0238125));
 #2571 = VERTEX_POINT('NONE', #2570);
-#2572 = CARTESIAN_POINT('NONE', (-0.0015096417774425879, -0.045565448541457644, 0.0254));
+#2572 = CARTESIAN_POINT('NONE', (-0.0015096417774425877, -0.045565448541457644, 0.0254));
 #2573 = VERTEX_POINT('NONE', #2572);
 #2574 = CARTESIAN_POINT('NONE', (-0.0010921999999999998, -0.04595367999999999, 0.0238125));
 #2575 = VERTEX_POINT('NONE', #2574);
@@ -10417,58 +10417,58 @@ DATA;
 #10401 = VECTOR('NONE', #10400, 1);
 #10402 = CARTESIAN_POINT('NONE', (-0.007619999999999999, -0.04635499999999999, 0.0254));
 #10403 = LINE('NONE', #10402, #10401);
-#10404 = DIRECTION('NONE', (-0.6800813455659818, -0.7331366608028573, 0));
+#10404 = DIRECTION('NONE', (-0.6800813455659819, -0.7331366608028572, 0));
 #10405 = VECTOR('NONE', #10404, 1);
-#10406 = CARTESIAN_POINT('NONE', (0.0020980400000000002, -0.04167632, 0.0238125));
+#10406 = CARTESIAN_POINT('NONE', (0.0020980400000000007, -0.04167632, 0.0238125));
 #10407 = LINE('NONE', #10406, #10405);
 #10408 = DIRECTION('NONE', (0, 0, 1));
 #10409 = VECTOR('NONE', #10408, 1);
-#10410 = CARTESIAN_POINT('NONE', (0.0012729244244215345, -0.0425658054737599, 0.0238125));
+#10410 = CARTESIAN_POINT('NONE', (0.0012729244244215347, -0.0425658054737599, 0.0238125));
 #10411 = LINE('NONE', #10410, #10409);
-#10412 = DIRECTION('NONE', (-0.6800813455659818, -0.7331366608028573, 0));
+#10412 = DIRECTION('NONE', (-0.6800813455659819, -0.7331366608028572, 0));
 #10413 = VECTOR('NONE', #10412, 1);
-#10414 = CARTESIAN_POINT('NONE', (0.0020980400000000002, -0.04167632, 0.0254));
+#10414 = CARTESIAN_POINT('NONE', (0.0020980400000000007, -0.04167632, 0.0254));
 #10415 = LINE('NONE', #10414, #10413);
 #10416 = DIRECTION('NONE', (0, 0, 1));
 #10417 = VECTOR('NONE', #10416, 1);
-#10418 = CARTESIAN_POINT('NONE', (0.0020980400000000002, -0.04167632, 0.0238125));
+#10418 = CARTESIAN_POINT('NONE', (0.0020980400000000007, -0.04167632, 0.0238125));
 #10419 = LINE('NONE', #10418, #10417);
-#10420 = DIRECTION('NONE', (0.5276972660417225, 0.8494325137479091, -0));
-#10421 = DIRECTION('NONE', (0.0000000000000025022368681948567, -0.000000000000001554477292738876, 1));
-#10422 = CARTESIAN_POINT('NONE', (0.0005008822163118523, -0.04380855921867364, 0.0238125));
+#10420 = DIRECTION('NONE', (0.5276972660417221, 0.8494325137479093, -0));
+#10421 = DIRECTION('NONE', (0.0000000000000025022368681948575, -0.0000000000000015544772927388748, 1));
+#10422 = CARTESIAN_POINT('NONE', (0.0005008822163118532, -0.04380855921867364, 0.0238125));
 #10423 = AXIS2_PLACEMENT_3D('NONE', #10422, #10421, #10420);
-#10424 = CIRCLE('NONE', #10423, 0.001463040000000001);
+#10424 = CIRCLE('NONE', #10423, 0.0014630400000000007);
 #10425 = DIRECTION('NONE', (0, 0, 1));
 #10426 = VECTOR('NONE', #10425, 1);
-#10427 = CARTESIAN_POINT('NONE', (-0.0006804866009285434, -0.0446716083246068, 0.0238125));
+#10427 = CARTESIAN_POINT('NONE', (-0.000680486600928543, -0.0446716083246068, 0.0238125));
 #10428 = LINE('NONE', #10427, #10426);
-#10429 = DIRECTION('NONE', (0.5276972660417225, 0.8494325137479091, -0));
-#10430 = DIRECTION('NONE', (-0.0000000000000025022368681948567, 0.000000000000001554477292738876, 1));
+#10429 = DIRECTION('NONE', (0.5276972660417224, 0.8494325137479088, -0));
+#10430 = DIRECTION('NONE', (-0.0000000000000025022368681948563, 0.0000000000000015544772927388758, 0.9999999999999998));
 #10431 = CARTESIAN_POINT('NONE', (0.0005008822163118523, -0.04380855921867364, 0.0254));
 #10432 = AXIS2_PLACEMENT_3D('NONE', #10431, #10430, #10429);
-#10433 = CIRCLE('NONE', #10432, 0.001463040000000001);
+#10433 = CIRCLE('NONE', #10432, 0.0014630400000000014);
 #10434 = DIRECTION('NONE', (-0.6800813455659821, -0.733136660802857, 0));
 #10435 = VECTOR('NONE', #10434, 1);
-#10436 = CARTESIAN_POINT('NONE', (-0.000680486600928543, -0.0446716083246068, 0.0238125));
+#10436 = CARTESIAN_POINT('NONE', (-0.0006804866009285428, -0.0446716083246068, 0.0238125));
 #10437 = LINE('NONE', #10436, #10435);
 #10438 = DIRECTION('NONE', (0, 0, 1));
 #10439 = VECTOR('NONE', #10438, 1);
-#10440 = CARTESIAN_POINT('NONE', (-0.0015096417774425879, -0.045565448541457644, 0.0238125));
+#10440 = CARTESIAN_POINT('NONE', (-0.0015096417774425877, -0.045565448541457644, 0.0238125));
 #10441 = LINE('NONE', #10440, #10439);
 #10442 = DIRECTION('NONE', (-0.6800813455659821, -0.733136660802857, 0));
 #10443 = VECTOR('NONE', #10442, 1);
-#10444 = CARTESIAN_POINT('NONE', (-0.000680486600928543, -0.0446716083246068, 0.0254));
+#10444 = CARTESIAN_POINT('NONE', (-0.0006804866009285428, -0.0446716083246068, 0.0254));
 #10445 = LINE('NONE', #10444, #10443);
-#10446 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166139, -0));
+#10446 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166137, -0));
 #10447 = DIRECTION('NONE', (0, 0, -1));
-#10448 = CARTESIAN_POINT('NONE', (0.0004985810518786167, -0.04381047558787883, 0.0238125));
+#10448 = CARTESIAN_POINT('NONE', (0.0004985810518786172, -0.04381047558787883, 0.0238125));
 #10449 = AXIS2_PLACEMENT_3D('NONE', #10448, #10447, #10446);
-#10450 = CIRCLE('NONE', #10449, 0.0026669999999999975);
-#10451 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166139, -0));
+#10450 = CIRCLE('NONE', #10449, 0.002666999999999998);
+#10451 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166137, -0));
 #10452 = DIRECTION('NONE', (0, 0, -1));
-#10453 = CARTESIAN_POINT('NONE', (0.0004985810518786167, -0.04381047558787883, 0.0254));
+#10453 = CARTESIAN_POINT('NONE', (0.0004985810518786172, -0.04381047558787883, 0.0254));
 #10454 = AXIS2_PLACEMENT_3D('NONE', #10453, #10452, #10451);
-#10455 = CIRCLE('NONE', #10454, 0.0026669999999999975);
+#10455 = CIRCLE('NONE', #10454, 0.002666999999999998);
 #10456 = DIRECTION('NONE', (0.6800813455659818, 0.7331366608028573, 0));
 #10457 = VECTOR('NONE', #10456, 1);
 #10458 = CARTESIAN_POINT('NONE', (-0.0010921999999999998, -0.04595367999999999, 0.0238125));
@@ -15570,24 +15570,24 @@ DATA;
 #15554 = DIRECTION('NONE', (1, 0, -0));
 #15555 = AXIS2_PLACEMENT_3D('NONE', #15553, #15554, $);
 #15556 = PLANE('NONE', #15555);
-#15557 = CARTESIAN_POINT('NONE', (0.001685482212210767, -0.04212106273687995, 0.024606250000000003));
-#15558 = DIRECTION('NONE', (-0.7331366608028554, 0.6800813455659833, -0));
+#15557 = CARTESIAN_POINT('NONE', (0.0016854822122107677, -0.04212106273687995, 0.024606250000000003));
+#15558 = DIRECTION('NONE', (-0.7331366608028557, 0.6800813455659834, -0));
 #15559 = AXIS2_PLACEMENT_3D('NONE', #15557, #15558, $);
 #15560 = PLANE('NONE', #15559);
 #15561 = CARTESIAN_POINT('NONE', (0.0005008822163118532, -0.04380855921867364, 0.02460625));
 #15562 = DIRECTION('NONE', (0, 0, 1));
-#15563 = DIRECTION('NONE', (0.527697266041722, 0.8494325137479093, -0));
+#15563 = DIRECTION('NONE', (0.5276972660417221, 0.8494325137479093, -0));
 #15564 = AXIS2_PLACEMENT_3D('NONE', #15561, #15562, #15563);
 #15565 = CYLINDRICAL_SURFACE('NONE', #15564, 0.0014630400000000007);
-#15566 = CARTESIAN_POINT('NONE', (-0.0010950641891855268, -0.045118528433032185, 0.02460625));
+#15566 = CARTESIAN_POINT('NONE', (-0.0010950641891855266, -0.045118528433032185, 0.02460625));
 #15567 = DIRECTION('NONE', (-0.733136660802859, 0.6800813455659798, -0));
 #15568 = AXIS2_PLACEMENT_3D('NONE', #15566, #15567, $);
 #15569 = PLANE('NONE', #15568);
-#15570 = CARTESIAN_POINT('NONE', (0.0004985810518786167, -0.04381047558787883, 0.02460625));
+#15570 = CARTESIAN_POINT('NONE', (0.0004985810518786172, -0.04381047558787883, 0.02460625));
 #15571 = DIRECTION('NONE', (0, 0, -1));
-#15572 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166139, -0));
+#15572 = DIRECTION('NONE', (-0.7529894373157879, -0.6580326035166137, -0));
 #15573 = AXIS2_PLACEMENT_3D('NONE', #15570, #15571, #15572);
-#15574 = CYLINDRICAL_SURFACE('NONE', #15573, 0.0026669999999999975);
+#15574 = CYLINDRICAL_SURFACE('NONE', #15573, 0.002666999999999998);
 #15575 = CARTESIAN_POINT('NONE', (-0.0006796422122107669, -0.045508937263120046, 0.024606250000000003));
 #15576 = DIRECTION('NONE', (0.7331366608028589, -0.68008134556598, 0));
 #15577 = AXIS2_PLACEMENT_3D('NONE', #15575, #15576, $);

rust/.config/nextest.toml

@@ -3,7 +3,7 @@
 # This way we don't start and stop too many engine instances, putting pressure on our cloud.
 uses-engine = { max-threads = 4 }
 # If a test must run after the engine tests, we want to make sure the engine tests are done first.
-after-engine = { depends-on = ["uses-engine"], max-threads = 12 }
+after-engine = { max-threads = 12 }
 
 [profile.default]
 slow-timeout = { period = "30s", terminate-after = 1 }

rust/Cargo.lock

@@ -1783,7 +1783,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "anyhow",
  "clap",
@@ -1794,7 +1794,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "Inflector",
  "anyhow",
@@ -1813,7 +1813,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.46"
+version = "0.1.49"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1822,7 +1822,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.47"
+version = "0.2.49"
 dependencies = [
  "anyhow",
  "clap",
@@ -1843,7 +1843,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "anyhow",
  "clap",
@@ -1863,7 +1863,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.47"
+version = "0.2.49"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -1917,6 +1917,7 @@ dependencies = [
  "tower-lsp",
  "ts-rs",
  "twenty-twenty",
+ "tynm",
  "url",
  "uuid",
  "validator",
@@ -1930,7 +1931,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.47"
+version = "0.3.49"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -1945,7 +1946,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -1958,7 +1959,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1972,7 +1973,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.47"
+version = "0.1.49"
 dependencies = [
  "bson",
  "console_error_panic_hook",
@@ -3096,15 +3097,14 @@ checksum = "e6cd655523701785087f69900df39892fb7b9b0721aa67682f571c38c32ac58a"
 
 [[package]]
 name = "ring"
-version = "0.17.8"
+version = "0.17.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
 dependencies = [
  "cc",
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
@@ -3559,12 +3559,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -4242,6 +4236,15 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "tynm"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd30d05e69d1478e13fe3e7a853409cfec82cebc2cf9b8d613b3c6b0081781ed"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "typenum"
 version = "1.17.0"

rust/justfile

@@ -54,6 +54,7 @@ bump-kcl-crate-versions bump='patch':
 publish-kcl version:
     git tag kcl-{{version}}
     cargo publish -p kcl-derive-docs
+    cargo publish -p kcl-directory-test-macro
     cargo publish -p kcl-lib
     cargo publish -p kcl-test-server
     # We push the tag at the end of publish since pushing the tag

rust/kcl-bumper/Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "kcl-bumper"
-version = "0.1.47"
+version = "0.1.49"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-api"
 rust-version = "1.76"
@@ -9,6 +9,11 @@ description = "Bumps versions in Cargo.toml"
 publish = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[[bin]]
+name = "kcl-bumper"
+path = "src/main.rs"
+bench = false
+
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["derive"] }

rust/kcl-derive-docs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-derive-docs"
 description = "A tool for generating documentation from Rust derive macros"
-version = "0.1.47"
+version = "0.1.49"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
@@ -9,6 +9,7 @@ repository = "https://github.com/KittyCAD/modeling-app"
 
 [lib]
 proc-macro = true
+bench = false
 
 [dependencies]
 Inflector = "0.11.4"

rust/kcl-directory-test-macro/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "kcl-directory-test-macro"
 description = "A tool for generating tests from a directory of kcl files"
-version = "0.1.46"
+version = "0.1.49"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
-publish = false
 
 [lib]
 proc-macro = true
+bench = false
 
 [dependencies]
 proc-macro2 = "1"

rust/kcl-directory-test-macro/src/lib.rs

@@ -1,6 +1,7 @@
+use std::fs;
+
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
-use std::fs;
 use syn::{parse_macro_input, LitStr};
 
 /// A macro that generates test functions for each directory within a given path.

rust/kcl-language-server-release/Cargo.toml

@@ -1,11 +1,16 @@
 [package]
 name = "kcl-language-server-release"
-version = "0.1.47"
+version = "0.1.49"
 edition = "2021"
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
 publish = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[[bin]]
+name = "kcl-language-server-release"
+path = "src/main.rs"
+bench = false
+
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["cargo", "derive", "env", "unicode"] }

rust/kcl-language-server-release/src/build.rs

@@ -72,7 +72,7 @@ impl Build {
 }
 
 fn build_client(sh: &Shell, version: &str, release_tag: &str, target: &Target) -> anyhow::Result<()> {
-    let bundle_path = Path::new("server");
+    let bundle_path = Path::new("kcl-language-server/server");
     sh.create_dir(bundle_path)?;
     sh.copy_file(&target.server_path, bundle_path)?;
     if let Some(symbols_path) = &target.symbols_path {

rust/kcl-language-server/Cargo.toml

@@ -2,7 +2,7 @@
 name = "kcl-language-server"
 description = "A language server for KCL."
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
-version = "0.2.47"
+version = "0.2.49"
 edition = "2021"
 license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,6 +10,7 @@ license = "MIT"
 [[bin]]
 name = "kcl-language-server"
 path = "src/main.rs"
+bench = false
 
 [dependencies]
 anyhow = { workspace = true }
@@ -41,13 +42,3 @@ tower-lsp = { version = "0.20.0", default-features = false, features = [
 
 [lints]
 workspace = true
-
-[profile.dev]
-# Disabling debug info speeds up builds a bunch,
-# and we don't rely on it for debugging that much.
-debug = 0
-
-[profile.release]
-incremental = true
-# Set this to 1 or 2 to get more useful backtraces in debugger.
-debug = 0

rust/kcl-language-server/client/src/bootstrap.ts

@@ -97,7 +97,7 @@ async function getServer(
       'You need to manually clone the kcl-lsp repository and ' +
       'run `cargo install` to build the language server from sources. ' +
       'If you feel that your platform should be supported, please create an issue ' +
-      'about that [here](https://github.com/kittycad/kcl-lsp/issues) and we ' +
+      'about that [here](https://github.com/kittycad/modeling-app/issues) and we ' +
       'will consider it.'
   )
   return undefined

rust/kcl-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.47"
+version = "0.2.49"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
@@ -11,6 +11,14 @@ keywords = ["kcl", "KittyCAD", "CAD"]
 exclude = ["tests/*", "benches/*", "examples/*", "e2e/*", "bindings/*", "fuzz/*"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+bench = false
+
+[[bin]]
+name = "kcl-lib-bin"
+path = "src/main.rs"
+bench = false
+
 [dependencies]
 anyhow = { workspace = true, features = ["backtrace"] }
 async-recursion = "1.1.1"
@@ -33,7 +41,7 @@ http = { workspace = true }
 image = { version = "0.25.5", default-features = false, features = ["png"] }
 indexmap = { workspace = true, features = ["serde"] }
 itertools = "0.13.0"
-kcl-derive-docs = { path = "../kcl-derive-docs" }
+kcl-derive-docs = { version = "0.1", path = "../kcl-derive-docs" }
 kittycad = { workspace = true }
 kittycad-modeling-cmds = { workspace = true }
 lazy_static = { workspace = true }
@@ -70,6 +78,7 @@ ts-rs = { version = "10.1.0", features = [
     "no-serde-warnings",
     "serde-json-impl",
 ] }
+tynm = "0.1.10"
 url = { version = "2.5.4", features = ["serde"] }
 uuid = { workspace = true, features = ["v4", "js", "serde"] }
 validator = { version = "0.20.0", features = ["derive"] }
@@ -114,7 +123,7 @@ expectorate = "1.1.0"
 handlebars = "6.3.0"
 image = { version = "0.25.5", default-features = false, features = ["png"] }
 insta = { version = "1.41.1", features = ["json", "filters", "redactions"] }
-kcl-directory-test-macro = { path = "../kcl-directory-test-macro" }
+kcl-directory-test-macro = { version = "0.1", path = "../kcl-directory-test-macro" }
 miette = { version = "7.5.0", features = ["fancy"] }
 pretty_assertions = "1.4.1"
 tokio = { version = "1.41.1", features = ["rt-multi-thread", "macros", "time"] }
@@ -137,7 +146,7 @@ harness = false
 required-features = ["lsp-test-util"]
 
 [[bench]]
-name = "executor_benchmark_criterion"
+name = "benchmark_kcl_samples"
 harness = false
 
 [[test]]

rust/kcl-lib/benches/benchmark_kcl_samples.rs

@@ -0,0 +1,105 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+const IGNORE_DIRS: [&str; 2] = ["step", "screenshots"];
+
+fn discover_benchmark_dirs(base_path: &Path) -> Vec<PathBuf> {
+    let mut benchmark_dirs = Vec::new();
+
+    if let Ok(entries) = fs::read_dir(base_path) {
+        for entry in entries.filter_map(Result::ok) {
+            let path = entry.path();
+            if path.is_dir() {
+                let dir_name = path.file_name().unwrap().to_string_lossy();
+                if !IGNORE_DIRS.iter().any(|&x| x == dir_name) {
+                    benchmark_dirs.push(path);
+                }
+            }
+        }
+    }
+
+    benchmark_dirs
+}
+
+fn find_main_kcl_file(dir_path: &Path) -> PathBuf {
+    let file_path = dir_path.join("main.kcl");
+
+    if !file_path.exists() || !file_path.is_file() {
+        panic!("Required main.kcl file not found in directory: {}", dir_path.display());
+    }
+
+    file_path
+}
+
+fn run_benchmarks(c: &mut Criterion) {
+    // Specify the base directory containing benchmark subdirectories
+    let base_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../public/kcl-samples");
+
+    if !base_dir.exists() || !base_dir.is_dir() {
+        panic!("Invalid base directory: {}", base_dir.display());
+    }
+
+    let benchmark_dirs = discover_benchmark_dirs(&base_dir);
+
+    //let rt = tokio::runtime::Runtime::new().unwrap();
+
+    for dir in benchmark_dirs {
+        let dir_name = dir.file_name().unwrap().to_string_lossy().to_string();
+
+        // Change the current directory to the benchmark directory.
+        // This is necessary for the kcl-lib to correctly resolve relative paths.
+        std::env::set_current_dir(&dir).unwrap();
+
+        // Find main.kcl file (will panic if not found)
+        let input_file = find_main_kcl_file(&dir);
+
+        // Read the file content (panic on failure)
+        let input_content = fs::read_to_string(&input_file)
+            .unwrap_or_else(|e| panic!("Failed to read main.kcl in directory {}: {}", dir_name, e));
+
+        // Create a benchmark group for this directory
+        let mut group = c.benchmark_group(&dir_name);
+        group
+            .sample_size(10)
+            .measurement_time(std::time::Duration::from_secs(1)); // Short measurement time to keep it from running in parallel
+
+        //let program = kcl_lib::Program::parse_no_errs(&input_content).unwrap();
+
+        group.bench_function(format!("parse_{}", dir_name), |b| {
+            b.iter(|| kcl_lib::Program::parse_no_errs(black_box(&input_content)).unwrap())
+        });
+
+        /*group.bench_function(format!("execute_{}", dir_name), |b| {
+            b.iter(|| {
+                let mut result = Err(());
+                for _ in 0..5 {
+                    // Try up to 3 times
+                    match rt.block_on(async {
+                        let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default()).await?;
+                        let mut exec_state = kcl_lib::ExecState::new(&ctx.settings);
+                        ctx.run(black_box(&program), &mut exec_state).await?;
+                        ctx.close().await;
+                        Ok::<(), anyhow::Error>(())
+                    }) {
+                        Ok(value) => {
+                            result = Ok(value);
+                            break;
+                        }
+                        Err(_) => continue,
+                    }
+                }
+
+                result.unwrap()
+            })
+        });*/
+
+        group.finish();
+    }
+}
+
+criterion_group!(benches, run_benchmarks);
+criterion_main!(benches);

rust/kcl-lib/benches/executor_benchmark_criterion.rs

@@ -1,56 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use kcl_lib::{test_server, UnitLength::Mm};
-use tokio::runtime::Runtime;
-
-pub fn bench_execute(c: &mut Criterion) {
-    for (name, code) in [
-        ("big_kitt", KITT_PROGRAM),
-        ("cube", CUBE_PROGRAM),
-        ("server_rack_lite", SERVER_RACK_LITE_PROGRAM),
-        ("server_rack_heavy", SERVER_RACK_HEAVY_PROGRAM),
-        ("lsystem", LSYSTEM_PROGRAM),
-    ] {
-        let mut group = c.benchmark_group("executor");
-        // Configure Criterion.rs to detect smaller differences and increase sample size to improve
-        // precision and counteract the resulting noise.
-        group.sample_size(10);
-        group.bench_with_input(BenchmarkId::new("execute", name), &code, |b, &s| {
-            let rt = Runtime::new().unwrap();
-            // Spawn a future onto the runtime
-            b.iter(|| {
-                rt.block_on(test_server::execute_and_snapshot(s, Mm, None)).unwrap();
-            });
-        });
-        group.finish();
-    }
-}
-
-pub fn bench_lego(c: &mut Criterion) {
-    let mut group = c.benchmark_group("executor_lego_pattern");
-    // Configure Criterion.rs to detect smaller differences and increase sample size to improve
-    // precision and counteract the resulting noise.
-    group.sample_size(10);
-    // Create lego bricks with N x 10 bumps, where N is each element of `sizes`.
-    let sizes = vec![1, 2, 4];
-    for size in sizes {
-        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
-            let rt = Runtime::new().unwrap();
-            let code = LEGO_PROGRAM.replace("{{N}}", &size.to_string());
-            // Spawn a future onto the runtime
-            b.iter(|| {
-                rt.block_on(test_server::execute_and_snapshot(&code, Mm, None)).unwrap();
-            });
-        });
-    }
-    group.finish();
-}
-
-criterion_group!(benches, bench_lego, bench_execute);
-criterion_main!(benches);
-
-const KITT_PROGRAM: &str = include_str!("../e2e/executor/inputs/kittycad_svg.kcl");
-const CUBE_PROGRAM: &str = include_str!("../e2e/executor/inputs/cube.kcl");
-const SERVER_RACK_HEAVY_PROGRAM: &str = include_str!("../e2e/executor/inputs/server-rack-heavy.kcl");
-const SERVER_RACK_LITE_PROGRAM: &str = include_str!("../e2e/executor/inputs/server-rack-lite.kcl");
-const LEGO_PROGRAM: &str = include_str!("../e2e/executor/inputs/slow_lego.kcl.tmpl");
-const LSYSTEM_PROGRAM: &str = include_str!("../e2e/executor/inputs/lsystem.kcl");

rust/kcl-lib/e2e/executor/inputs/fillet_duplicate_tags.kcl

@@ -1,8 +1,15 @@
-const part001 = startSketchOn('XY')
-    |> startProfileAt([0,0], %)
-    |> line(end = [0, 10], tag = $thing)
-    |> line(end = [10, 0])
-    |> line(end = [0, -10], tag = $thing2)
-    |> close()
-    |> extrude(length = 10)
-    |> fillet(radius = 0.5, tags = [thing, thing])
+startProfileAt([0, 0], startSketchOn("XY"))
+  |> xLine(length = 10, tag = $line000)
+  |> yLine(length = 10, tag = $line001)
+  |> xLine(endAbsolute = profileStartX(%), tag = $line002)
+  |> close(tag = $line003)
+  |> extrude(length = 10)
+  |> fillet(
+       radius = 1,
+       tags = [
+         line003,
+         getNextAdjacentEdge(line000),
+         getPreviousAdjacentEdge(line001)
+       ],
+     )
+

rust/kcl-lib/e2e/executor/main.rs

@@ -27,11 +27,14 @@ async fn kcl_test_fillet_duplicate_tags() {
     let code = kcl_input!("fillet_duplicate_tags");
 
     let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
-    assert!(result.is_err());
+    let err = result.expect_err("Code should have failed due to the duplicate edges being filletted");
+
+    let err = err.as_kcl_error().unwrap();
     assert_eq!(
-        result.err().unwrap().to_string(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([229, 272, 0])], message: "Duplicate tags are not allowed." }"#,
+        err.message(),
+        "The same edge ID is being referenced multiple times, which is not allowed. Please select a different edge"
     );
+    assert_eq!(err.source_ranges().len(), 2);
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -857,7 +860,7 @@ part = rectShape([0, 0], 20, 20)
     };
     assert_eq!(
         err.error.message(),
-        "Expected a kcl_lib::std::shapes::SketchOrSurface but found string (text)"
+        "This function expected this argument to be of type SketchOrSurface but it's actually of type string (text)"
     );
 }
 
@@ -2086,6 +2089,26 @@ async fn kcl_test_ensure_nothing_left_in_batch_multi_file() {
     ctx.close().await;
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn kcl_test_better_type_names() {
+    let code = r#"startSketchOn('XY')
+  |> circle(center = [-95.51, -74.7], radius = 262.23)
+  |> appearance(metalness = 0.9)
+"#;
+    let result = execute_and_snapshot(code, UnitLength::Mm, None).await;
+
+    let err = match result.err() {
+        Some(x) => match x {
+            ExecError::Kcl(kcl_error_with_outputs) => kcl_error_with_outputs.error.message().to_owned(),
+            ExecError::Connection(_) => todo!(),
+            ExecError::BadPng(_) => todo!(),
+            ExecError::BadExport(_) => todo!(),
+        },
+        None => todo!(),
+    };
+    assert_eq!(err, "This function expected this argument to be of type SolidSet but it's actually of type Sketch. You can convert a sketch (2D) into a Solid (3D) by calling a function like `extrude` or `revolve`");
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn kcl_test_exporting_step_file() {
     // This tests export like how we do it in cli and kcl.py.

rust/kcl-lib/src/docs/gen_std_tests.rs

@@ -21,7 +21,7 @@ use crate::{
 };
 
 const TYPES_DIR: &str = "../../docs/kcl/types";
-const LANG_TOPICS: [&str; 4] = ["Types", "Modules", "Settings", "Known Issues"];
+const LANG_TOPICS: [&str; 5] = ["Types", "Modules", "Settings", "Known Issues", "Constants"];
 // These types are declared in std.
 const DECLARED_TYPES: [&str; 7] = ["number", "string", "tag", "bool", "Sketch", "Solid", "Plane"];
 
@@ -298,6 +298,7 @@ fn init_handlebars() -> Result<handlebars::Handlebars<'static>> {
     hbs.register_template_string("propertyType", include_str!("templates/propertyType.hbs"))?;
     hbs.register_template_string("schema", include_str!("templates/schema.hbs"))?;
     hbs.register_template_string("index", include_str!("templates/index.hbs"))?;
+    hbs.register_template_string("consts-index", include_str!("templates/consts-index.hbs"))?;
     hbs.register_template_string("function", include_str!("templates/function.hbs"))?;
     hbs.register_template_string("const", include_str!("templates/const.hbs"))?;
     hbs.register_template_string("type", include_str!("templates/type.hbs"))?;
@@ -312,6 +313,9 @@ fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &[Doc
     let mut functions = HashMap::new();
     functions.insert("std".to_owned(), Vec::new());
 
+    let mut constants = HashMap::new();
+    constants.insert("std".to_owned(), Vec::new());
+
     for key in combined.keys() {
         let internal_fn = combined
             .get(key)
@@ -337,6 +341,13 @@ fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &[Doc
             DocData::Const(c) => (c.name.clone(), d.file_name()),
             DocData::Ty(t) => (t.name.clone(), d.file_name()),
         });
+
+        if let DocData::Const(c) = d {
+            constants
+                .entry(d.mod_name())
+                .or_default()
+                .push((c.name.clone(), d.file_name()));
+        }
     }
 
     // TODO we should sub-divide into types, constants, and functions.
@@ -362,7 +373,7 @@ fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &[Doc
         .map(|name| {
             json!({
                 "name": name,
-                "file_name": name.to_lowercase().replace(' ', "-"),
+                "file_name": name.to_lowercase().replace(' ', "-").replace("constants", "consts"),
             })
         })
         .collect();
@@ -375,6 +386,31 @@ fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &[Doc
 
     expectorate::assert_contents("../../docs/kcl/index.md", &output);
 
+    // Generate the index for the constants.
+    let mut sorted_consts: Vec<_> = constants
+        .into_iter()
+        .map(|(m, mut consts)| {
+            consts.sort();
+            let val = json!({
+                "name": m,
+                "consts": consts.into_iter().map(|(n, f)| json!({
+                    "name": n,
+                    "file_name": f,
+                })).collect::<Vec<_>>(),
+            });
+            (m, val)
+        })
+        .collect();
+    sorted_consts.sort_by(|t1, t2| t1.0.cmp(&t2.0));
+    let data: Vec<_> = sorted_consts.into_iter().map(|(_, val)| val).collect();
+    let data = json!({
+        "consts": data,
+    });
+
+    let output = hbs.render("consts-index", &data)?;
+
+    expectorate::assert_contents("../../docs/kcl/consts.md", &output);
+
     Ok(())
 }
 
@@ -405,7 +441,7 @@ fn generate_example(index: usize, src: &str, props: &ExampleProperties, file_nam
     }))
 }
 
-fn generate_type_from_kcl(ty: &TyData, file_name: String) -> Result<()> {
+fn generate_type_from_kcl(ty: &TyData, file_name: String, example_name: String) -> Result<()> {
     if ty.properties.doc_hidden {
         return Ok(());
     }
@@ -416,7 +452,7 @@ fn generate_type_from_kcl(ty: &TyData, file_name: String) -> Result<()> {
         .examples
         .iter()
         .enumerate()
-        .filter_map(|(index, example)| generate_example(index, &example.0, &example.1, &file_name))
+        .filter_map(|(index, example)| generate_example(index, &example.0, &example.1, &example_name))
         .collect();
 
     let data = json!({
@@ -428,7 +464,7 @@ fn generate_type_from_kcl(ty: &TyData, file_name: String) -> Result<()> {
     });
 
     let output = hbs.render("kclType", &data)?;
-    expectorate::assert_contents(format!("../../docs/kcl/types/{}.md", file_name), &output);
+    expectorate::assert_contents(format!("../../docs/kcl/{}.md", file_name), &output);
 
     Ok(())
 }
@@ -480,7 +516,7 @@ fn generate_function_from_kcl(function: &FnData, file_name: String) -> Result<()
     Ok(())
 }
 
-fn generate_const_from_kcl(cnst: &ConstData, file_name: String) -> Result<()> {
+fn generate_const_from_kcl(cnst: &ConstData, file_name: String, example_name: String) -> Result<()> {
     if cnst.properties.doc_hidden {
         return Ok(());
     }
@@ -490,7 +526,7 @@ fn generate_const_from_kcl(cnst: &ConstData, file_name: String) -> Result<()> {
         .examples
         .iter()
         .enumerate()
-        .filter_map(|(index, example)| generate_example(index, &example.0, &example.1, &file_name))
+        .filter_map(|(index, example)| generate_example(index, &example.0, &example.1, &example_name))
         .collect();
 
     let data = json!({
@@ -1028,8 +1064,8 @@ fn test_generate_stdlib_markdown_docs() {
     for d in &kcl_std {
         match d {
             DocData::Fn(f) => generate_function_from_kcl(f, d.file_name()).unwrap(),
-            DocData::Const(c) => generate_const_from_kcl(c, d.file_name()).unwrap(),
-            DocData::Ty(t) => generate_type_from_kcl(t, d.file_name()).unwrap(),
+            DocData::Const(c) => generate_const_from_kcl(c, d.file_name(), d.example_name()).unwrap(),
+            DocData::Ty(t) => generate_type_from_kcl(t, d.file_name(), d.example_name()).unwrap(),
         }
     }
 }
@@ -1061,7 +1097,8 @@ fn test_generate_stdlib_json_schema() {
 async fn test_code_in_topics() {
     let mut join_set = JoinSet::new();
     for name in LANG_TOPICS {
-        let filename = format!("../../docs/kcl/{}.md", name.to_lowercase().replace(' ', "-"));
+        let filename =
+            format!("../../docs/kcl/{}.md", name.to_lowercase().replace(' ', "-")).replace("constants", "consts");
         let mut file = File::open(&filename).unwrap();
         let mut text = String::new();
         file.read_to_string(&mut text).unwrap();

rust/kcl-lib/src/docs/kcl_doc.rs

@@ -116,10 +116,18 @@ impl DocData {
 
     #[allow(dead_code)]
     pub fn file_name(&self) -> String {
+        match self {
+            DocData::Fn(f) => f.qual_name.replace("::", "-"),
+            DocData::Const(c) => format!("consts/{}", c.qual_name.replace("::", "-")),
+            DocData::Ty(t) => format!("types/{}", t.name.clone()),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn example_name(&self) -> String {
         match self {
             DocData::Fn(f) => f.qual_name.replace("::", "-"),
             DocData::Const(c) => format!("const_{}", c.qual_name.replace("::", "-")),
-            // TODO might want to change this
             DocData::Ty(t) => t.name.clone(),
         }
     }
@@ -872,7 +880,7 @@ mod test {
                         Ok(img) => img,
                     };
                 twenty_twenty::assert_image(
-                    format!("tests/outputs/serial_test_example_{}{i}.png", d.file_name()),
+                    format!("tests/outputs/serial_test_example_{}{i}.png", d.example_name()),
                     &result,
                     0.99,
                 );

rust/kcl-lib/src/docs/mod.rs

@@ -133,6 +133,7 @@ impl StdLibFnArg {
             || self.type_ == "SolidSet"
             || self.type_ == "SketchSurface"
             || self.type_ == "SketchOrSurface"
+            || self.type_ == "SolidOrImportedGeometry"
         {
             return Ok(Some((index, format!("{label}${{{}:{}}}", index, "%"))));
         } else if (self.type_ == "TagDeclarator" || self.type_ == "TagNode") && self.required {

rust/kcl-lib/src/docs/templates/consts-index.hbs

@@ -0,0 +1,17 @@
+---
+title: "KCL Constants"
+excerpt: "Documentation for the KCL constants."
+layout: manual
+---
+
+## Table of Contents
+
+{{#each consts}}
+
+### `{{name}}`
+
+{{#each consts}}
+- [`{{name}}`](/docs/kcl/{{file_name}})
+{{/each}}
+{{/each}}
+

rust/kcl-lib/src/errors.rs

@@ -48,6 +48,15 @@ impl ExecErrorWithState {
     }
 }
 
+impl ExecError {
+    pub fn as_kcl_error(&self) -> Option<&crate::KclError> {
+        let ExecError::Kcl(k) = &self else {
+            return None;
+        };
+        Some(&k.error)
+    }
+}
+
 impl From<ExecError> for ExecErrorWithState {
     fn from(error: ExecError) -> Self {
         Self {

rust/kcl-lib/src/execution/geometry.rs

@@ -223,6 +223,33 @@ pub struct ImportedGeometry {
     pub meta: Vec<Metadata>,
 }
 
+/// Data for a solid or an imported geometry.
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[ts(export)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum SolidOrImportedGeometry {
+    Solid(Box<Solid>),
+    ImportedGeometry(Box<ImportedGeometry>),
+}
+
+impl SolidOrImportedGeometry {
+    pub fn id(&self) -> uuid::Uuid {
+        match self {
+            SolidOrImportedGeometry::Solid(s) => s.id,
+            SolidOrImportedGeometry::ImportedGeometry(s) => s.id,
+        }
+    }
+}
+
+impl From<SolidOrImportedGeometry> for crate::execution::KclValue {
+    fn from(value: SolidOrImportedGeometry) -> Self {
+        match value {
+            SolidOrImportedGeometry::Solid(s) => crate::execution::KclValue::Solid { value: s },
+            SolidOrImportedGeometry::ImportedGeometry(s) => crate::execution::KclValue::ImportedGeometry(*s),
+        }
+    }
+}
+
 /// A helix.
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]

rust/kcl-lib/src/execution/mod.rs

@@ -64,8 +64,6 @@ pub struct ExecOutcome {
     /// Operations that have been performed in execution order, for display in
     /// the Feature Tree.
     pub operations: Vec<Operation>,
-    /// Output map of UUIDs to artifacts.
-    pub artifacts: IndexMap<ArtifactId, Artifact>,
     /// Output commands to allow building the artifact graph by the caller.
     pub artifact_commands: Vec<ArtifactCommand>,
     /// Output artifact graph.

rust/kcl-lib/src/execution/state.rs

@@ -123,7 +123,6 @@ impl ExecState {
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect(),
             operations: self.global.operations,
-            artifacts: self.global.artifacts,
             artifact_commands: self.global.artifact_commands,
             artifact_graph: self.global.artifact_graph,
             errors: self.global.errors,
@@ -146,7 +145,6 @@ impl ExecState {
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect(),
             operations: Default::default(),
-            artifacts: Default::default(),
             artifact_commands: Default::default(),
             artifact_graph: Default::default(),
             errors: self.global.errors,

rust/kcl-lib/src/parsing/parser.rs

@@ -844,11 +844,23 @@ fn object_property(i: &mut TokenSlice) -> PResult<Node<ObjectProperty>> {
         ))
         .parse_next(i)?;
     ignore_whitespace(i);
-    let expr = expression
+    let expr = match expression
         .context(expected(
             "the value which you're setting the property to, e.g. in 'height: 4', the value is 4",
         ))
-        .parse_next(i)?;
+        .parse_next(i)
+    {
+        Ok(expr) => expr,
+        Err(_) => {
+            return Err(ErrMode::Cut(
+                CompilationError::fatal(
+                    SourceRange::from(sep),
+                    "This property has a label, but no value. Put some value after the equals sign",
+                )
+                .into(),
+            ));
+        }
+    };
 
     let result = Node {
         start: key.start,
@@ -2810,7 +2822,7 @@ fn fn_call_kw(i: &mut TokenSlice) -> PResult<Node<CallExpressionKw>> {
     ignore_whitespace(i);
 
     #[allow(clippy::large_enum_variant)]
-    pub enum ArgPlace {
+    enum ArgPlace {
         NonCode(Node<NonCodeNode>),
         LabeledArg(LabeledArg),
         UnlabeledArg(Expr),
@@ -2827,22 +2839,34 @@ fn fn_call_kw(i: &mut TokenSlice) -> PResult<Node<CallExpressionKw>> {
     .parse_next(i)?;
     let (args, non_code_nodes): (Vec<_>, BTreeMap<usize, _>) = args.into_iter().enumerate().try_fold(
         (Vec::new(), BTreeMap::new()),
-        |(mut args, mut non_code_nodes), (i, e)| {
+        |(mut args, mut non_code_nodes), (index, e)| {
             match e {
                 ArgPlace::NonCode(x) => {
-                    non_code_nodes.insert(i, vec![x]);
+                    non_code_nodes.insert(index, vec![x]);
                 }
                 ArgPlace::LabeledArg(x) => {
                     args.push(x);
                 }
                 ArgPlace::UnlabeledArg(arg) => {
-                    return Err(ErrMode::Cut(
-                        CompilationError::fatal(
-                            SourceRange::from(arg),
-                            "This argument needs a label, but it doesn't have one",
+                    let followed_by_equals = peek((opt(whitespace), equals)).parse_next(i).is_ok();
+                    let err = if followed_by_equals {
+                        ErrMode::Cut(
+                            CompilationError::fatal(
+                                SourceRange::from(arg),
+                                "This argument has a label, but no value. Put some value after the equals sign",
+                            )
+                            .into(),
                         )
-                        .into(),
-                    ));
+                    } else {
+                        ErrMode::Cut(
+                            CompilationError::fatal(
+                                SourceRange::from(arg),
+                                "This argument needs a label, but it doesn't have one",
+                            )
+                            .into(),
+                        )
+                    };
+                    return Err(err);
                 }
             }
             Ok((args, non_code_nodes))
@@ -4678,6 +4702,42 @@ baz = 2
             );
         }
     }
+
+    #[test]
+    fn test_sensible_error_when_missing_rhs_of_kw_arg() {
+        for (i, program) in ["f(x, y=)"].into_iter().enumerate() {
+            let tokens = crate::parsing::token::lex(program, ModuleId::default()).unwrap();
+            let err = fn_call_kw.parse(tokens.as_slice()).unwrap_err();
+            let cause = err.inner().cause.as_ref().unwrap();
+            assert_eq!(
+                cause.message, "This argument has a label, but no value. Put some value after the equals sign",
+                "failed test {i}: {program}"
+            );
+            assert_eq!(
+                cause.source_range.start(),
+                program.find("y").unwrap(),
+                "failed test {i}: {program}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_sensible_error_when_missing_rhs_of_obj_property() {
+        for (i, program) in ["{x = 1, y =}"].into_iter().enumerate() {
+            let tokens = crate::parsing::token::lex(program, ModuleId::default()).unwrap();
+            let err = object.parse(tokens.as_slice()).unwrap_err();
+            let cause = err.inner().cause.as_ref().unwrap();
+            assert_eq!(
+                cause.message, "This property has a label, but no value. Put some value after the equals sign",
+                "failed test {i}: {program}"
+            );
+            assert_eq!(
+                cause.source_range.start(),
+                program.rfind('=').unwrap(),
+                "failed test {i}: {program}"
+            );
+        }
+    }
 }
 
 #[cfg(test)]

rust/kcl-lib/src/settings/generate_settings_docs.rs

@@ -0,0 +1,232 @@
+use std::{fs, path::PathBuf};
+
+use schemars::{gen::SchemaGenerator, JsonSchema};
+use serde_json::{json, Value};
+
+use crate::settings::types::{project::ProjectConfiguration, Configuration};
+
+// Project settings example in TOML format
+const PROJECT_SETTINGS_EXAMPLE: &str = r#"[settings.app]
+# Set the appearance of the application
+name = "My Awesome Project"
+
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark" 
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use inches as the default measurement unit
+base_unit = "in"
+"#;
+
+// User settings example in TOML format
+const USER_SETTINGS_EXAMPLE: &str = r#"[settings.app]
+# Set the appearance of the application
+[settings.app.appearance]
+# Use dark mode theme
+theme = "dark"
+# Set the app color to blue (240.0 = blue, 0.0 = red, 120.0 = green)
+color = 240.0
+
+[settings.modeling]
+# Use millimeters as the default measurement unit
+base_unit = "mm"
+
+[settings.text_editor]
+# Disable text wrapping in the editor
+text_wrapping = false
+"#;
+
+const PROJECT_SETTINGS_DOC_PATH: &str = "../../docs/kcl/settings/project.md";
+const USER_SETTINGS_DOC_PATH: &str = "../../docs/kcl/settings/user.md";
+
+fn init_handlebars() -> handlebars::Handlebars<'static> {
+    let mut hbs = handlebars::Handlebars::new();
+
+    // Register helper to pretty-format enum values
+    hbs.register_helper(
+        "pretty_enum",
+        Box::new(
+            |h: &handlebars::Helper,
+             _: &handlebars::Handlebars,
+             _: &handlebars::Context,
+             _: &mut handlebars::RenderContext,
+             out: &mut dyn handlebars::Output|
+             -> handlebars::HelperResult {
+                if let Some(enum_value) = h.param(0) {
+                    if let Some(array) = enum_value.value().as_array() {
+                        let pretty_options = array
+                            .iter()
+                            .filter_map(|v| v.as_str())
+                            .map(|s| format!("`{}`", s))
+                            .collect::<Vec<_>>()
+                            .join(", ");
+                        out.write(&pretty_options)?;
+                        return Ok(());
+                    }
+                }
+                out.write("No options available")?;
+                Ok(())
+            },
+        ),
+    );
+
+    // Helper to format default values better
+    hbs.register_helper(
+        "format_default",
+        Box::new(
+            |h: &handlebars::Helper,
+             _: &handlebars::Handlebars,
+             _: &handlebars::Context,
+             _: &mut handlebars::RenderContext,
+             out: &mut dyn handlebars::Output|
+             -> handlebars::HelperResult {
+                if let Some(default) = h.param(0) {
+                    let val = default.value();
+                    match val {
+                        Value::Null => out.write("None")?,
+                        Value::Bool(b) => out.write(&b.to_string())?,
+                        Value::Number(n) => out.write(&n.to_string())?,
+                        Value::String(s) => out.write(&format!("`{}`", s))?,
+                        Value::Array(arr) => {
+                            let formatted = arr
+                                .iter()
+                                .map(|v| match v {
+                                    Value::String(s) => format!("`{}`", s),
+                                    _ => format!("{}", v),
+                                })
+                                .collect::<Vec<_>>()
+                                .join(", ");
+                            out.write(&format!("[{}]", formatted))?;
+                        }
+                        Value::Object(_) => out.write("(complex default)")?,
+                    }
+                    return Ok(());
+                }
+                out.write("None")?;
+                Ok(())
+            },
+        ),
+    );
+
+    // Register the settings template
+    hbs.register_template_string("settings", include_str!("templates/settings.hbs"))
+        .expect("Failed to register settings template");
+
+    hbs
+}
+
+fn ensure_settings_dir() {
+    let settings_dir = PathBuf::from("../../docs/kcl/settings");
+    if !settings_dir.exists() {
+        fs::create_dir_all(&settings_dir).expect("Failed to create settings directory");
+    }
+}
+
+pub fn generate_settings_docs() {
+    ensure_settings_dir();
+    let hbs = init_handlebars();
+
+    // Generate project settings documentation
+    let mut settings = schemars::gen::SchemaSettings::default();
+    settings.inline_subschemas = true;
+    settings.meta_schema = None; // We don't need the meta schema for docs
+    settings.option_nullable = false; // Important - makes Option fields show properly
+    settings.option_add_null_type = false;
+
+    let mut generator = SchemaGenerator::new(settings.clone());
+    let project_schema = ProjectConfiguration::json_schema(&mut generator);
+
+    // For debugging the schema:
+    // fs::write("/tmp/project_schema.json", serde_json::to_string_pretty(&project_schema).unwrap())
+    //     .expect("Failed to write debug schema");
+
+    // Extract the description from the schema metadata
+    let project_description = if let schemars::schema::Schema::Object(obj) = &project_schema {
+        if let Some(metadata) = &obj.metadata {
+            metadata.description.clone().unwrap_or_default()
+        } else {
+            "Project specific settings for the KittyCAD modeling app.".to_string()
+        }
+    } else {
+        "Project specific settings for the KittyCAD modeling app.".to_string()
+    };
+
+    // Convert the schema to our template format
+    let project_data = json!({
+        "title": "Project Settings",
+        "description": project_description,
+        "config_type": "Project Configuration",
+        "file_name": "project.toml",
+        "settings": json!(project_schema),
+        "example": PROJECT_SETTINGS_EXAMPLE
+    });
+
+    let project_output = hbs
+        .render("settings", &project_data)
+        .expect("Failed to render project settings documentation");
+
+    expectorate::assert_contents(PROJECT_SETTINGS_DOC_PATH, &project_output);
+
+    // Generate user settings documentation
+    let mut generator = SchemaGenerator::new(settings);
+    let user_schema = Configuration::json_schema(&mut generator);
+
+    // For debugging the schema:
+    // fs::write("/tmp/user_schema.json", serde_json::to_string_pretty(&user_schema).unwrap())
+    //     .expect("Failed to write debug schema");
+
+    // Extract the description from the schema metadata
+    let user_description = if let schemars::schema::Schema::Object(obj) = &user_schema {
+        if let Some(metadata) = &obj.metadata {
+            metadata.description.clone().unwrap_or_default()
+        } else {
+            "User-specific configuration options for the KittyCAD modeling app.".to_string()
+        }
+    } else {
+        "User-specific configuration options for the KittyCAD modeling app.".to_string()
+    };
+
+    // Trim any trailing periods to avoid double periods
+
+    let user_data = json!({
+        "title": "User Settings",
+        "description": user_description,
+        "config_type": "User Configuration",
+        "file_name": "user.toml",
+        "settings": json!(user_schema),
+        "example": USER_SETTINGS_EXAMPLE
+    });
+
+    let user_output = hbs
+        .render("settings", &user_data)
+        .expect("Failed to render user settings documentation");
+
+    expectorate::assert_contents(USER_SETTINGS_DOC_PATH, &user_output);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_generate_settings_docs() {
+        // First verify that our TOML examples are valid and match the expected types
+        let _project_config: ProjectConfiguration = toml::from_str(PROJECT_SETTINGS_EXAMPLE)
+            .expect("Project settings example is not valid according to ProjectConfiguration");
+        let _user_config: Configuration = toml::from_str(USER_SETTINGS_EXAMPLE)
+            .expect("User settings example is not valid according to Configuration");
+
+        // Expectorate will verify the output matches what we expect,
+        // or update it if run with EXPECTORATE=overwrite
+        generate_settings_docs();
+
+        // Verify files exist
+        let project_path = PathBuf::from(PROJECT_SETTINGS_DOC_PATH);
+        let user_path = PathBuf::from(USER_SETTINGS_DOC_PATH);
+        assert!(project_path.exists(), "Project settings documentation not generated");
+        assert!(user_path.exists(), "User settings documentation not generated");
+    }
+}

rust/kcl-lib/src/settings/mod.rs

@@ -1,3 +1,6 @@
 //! This module contains settings for kcl projects as well as the modeling app.
 
 pub mod types;
+
+#[cfg(test)]
+mod generate_settings_docs;

rust/kcl-lib/src/settings/templates/settings.hbs

@@ -0,0 +1,67 @@
+---
+title: "{{title}}"
+excerpt: "{{{description}}}"
+layout: manual
+---
+
+# {{title}}
+
+{{{description}}}
+
+## {{config_type}} Structure
+
+```toml
+{{{example}}}
+```
+
+## Available Settings
+
+{{#with settings.properties}}
+{{#each this}}
+### {{@key}}
+
+{{#if metadata.description}}{{metadata.description}}{{/if}}
+
+{{#with properties}}
+{{#each this}}
+#### {{@key}}
+
+{{#if description}}{{description}}{{/if}}
+
+{{#if enum}}
+**Possible values:** {{pretty_enum enum}}
+{{/if}}
+
+**Default:** {{#if default}}{{format_default default}}{{else}}None{{/if}}
+
+{{#if properties}}
+This setting has the following nested options:
+
+{{#each properties}}
+##### {{@key}}
+
+{{#if description}}{{description}}{{/if}}
+
+{{#if enum}}
+**Possible values:** {{pretty_enum enum}}
+{{/if}}
+
+**Default:** {{#if default}}{{format_default default}}{{else}}None{{/if}}
+
+{{#if properties}}
+This setting has further nested options. See the schema for full details.
+{{/if}}
+{{/each}}
+{{/if}}
+
+{{/each}}
+{{/with}}
+
+{{/each}}
+{{/with}}
+
+## Complete Example
+
+```toml
+{{{example}}}
+```

rust/kcl-lib/src/settings/types/mod.rs

@@ -11,7 +11,11 @@ use validator::{Validate, ValidateRange};
 const DEFAULT_THEME_COLOR: f64 = 264.5;
 const DEFAULT_PROJECT_NAME_TEMPLATE: &str = "project-$nnn";
 
-/// High level configuration.
+/// User specific settings for the app.
+/// These live in `user.toml` in the app's configuration directory.
+/// Updating the settings in the app will update this file automatically.
+/// Do not edit this file manually, as it may be overwritten by the app.
+/// Manual edits can cause corruption of the settings file.
 #[derive(Debug, Default, Clone, Deserialize, Serialize, JsonSchema, ts_rs::TS, PartialEq, Validate)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]

rust/kcl-lib/src/settings/types/project.rs

@@ -10,7 +10,11 @@ use crate::settings::types::{
     is_default, AppColor, CommandBarSettings, DefaultTrue, FloatOrInt, OnboardingStatus, TextEditorSettings, UnitLength,
 };
 
-/// High level project configuration.
+/// Project specific settings for the app.
+/// These live in `project.toml` in the base of the project directory.
+/// Updating the settings for the project in the app will update this file automatically.
+/// Do not edit this file manually, as it may be overwritten by the app.
+/// Manual edits can cause corruption of the settings file.
 #[derive(Debug, Default, Clone, Deserialize, Serialize, JsonSchema, ts_rs::TS, PartialEq, Validate)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]

rust/kcl-lib/src/simulation_tests.rs

@@ -27,7 +27,7 @@ struct Test {
 }
 
 pub(crate) const RENDERED_MODEL_NAME: &str = "rendered_model.png";
-pub(crate) const EXPORTED_STEP_NAME: &str = "exported_step.linux.step";
+pub(crate) const EXPORTED_STEP_NAME: &str = "exported_step.step";
 
 impl Test {
     fn new(name: &str) -> Self {
@@ -77,7 +77,7 @@ fn read<P>(filename: &str, dir: P) -> String
 where
     P: AsRef<Path>,
 {
-    std::fs::read_to_string(dir.as_ref().join(filename)).unwrap()
+    std::fs::read_to_string(dir.as_ref().join(filename)).expect("Failed to read file: {filename}")
 }
 
 fn parse(test_name: &str) {
@@ -145,13 +145,9 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
             }
             if export_step {
                 let step = step.unwrap();
-                let step_str = std::str::from_utf8(&step).unwrap();
-                // We use expectorate here so we can see the diff in ci.
-                expectorate::assert_contents(
-                    test.output_dir
-                        .join(format!("exported_step.{}.step", std::env::consts::OS)),
-                    step_str,
-                );
+                // We do not use expectorate here because the output is non-deterministic
+                // due to SSI and GPU.
+                std::fs::write(test.output_dir.join(EXPORTED_STEP_NAME), step).unwrap();
             }
             let outcome = exec_state.to_wasm_outcome(env_ref);
             assert_common_snapshots(
@@ -2140,3 +2136,25 @@ mod flush_batch_on_end {
         super::execute(TEST_NAME, true).await
     }
 }
+
+mod import_transform {
+    const TEST_NAME: &str = "import_transform";
+
+    /// Test parsing KCL.
+    #[test]
+    fn parse() {
+        super::parse(TEST_NAME);
+    }
+
+    /// Test that parsing and unparsing KCL produces the original KCL input.
+    #[test]
+    fn unparse() {
+        super::unparse(TEST_NAME)
+    }
+
+    /// Test that KCL is executed correctly.
+    #[tokio::test(flavor = "multi_thread")]
+    async fn kcl_test_execute() {
+        super::execute(TEST_NAME, true).await
+    }
+}

rust/kcl-lib/src/std/args.rs

@@ -159,6 +159,49 @@ impl Args {
         })
     }
 
+    /// Get a labelled keyword arg, check it's an array, and return all items in the array
+    /// plus their source range.
+    pub(crate) fn kw_arg_array_and_source<'a, T>(&'a self, label: &str) -> Result<Vec<(T, SourceRange)>, KclError>
+    where
+        T: FromKclValue<'a>,
+    {
+        let Some(arg) = self.kw_args.labeled.get(label) else {
+            let err = KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![self.source_range],
+                message: format!("This function requires a keyword argument '{label}'"),
+            });
+            return Err(err);
+        };
+        let Some(array) = arg.value.as_array() else {
+            let err = KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![arg.source_range],
+                message: format!(
+                    "Expected an array of {} but found {}",
+                    type_name::<T>(),
+                    arg.value.human_friendly_type()
+                ),
+            });
+            return Err(err);
+        };
+        array
+            .iter()
+            .map(|item| {
+                let source = SourceRange::from(item);
+                let val = FromKclValue::from_kcl_val(item).ok_or_else(|| {
+                    KclError::Semantic(KclErrorDetails {
+                        source_ranges: arg.source_ranges(),
+                        message: format!(
+                            "Expected a {} but found {}",
+                            type_name::<T>(),
+                            arg.value.human_friendly_type()
+                        ),
+                    })
+                })?;
+                Ok((val, source))
+            })
+            .collect::<Result<Vec<_>, _>>()
+    }
+
     /// Get the unlabeled keyword argument. If not set, returns None.
     pub(crate) fn unlabeled_kw_arg_unconverted(&self) -> Option<&Arg> {
         self.kw_args
@@ -182,13 +225,22 @@ impl Args {
             }))?;
 
         T::from_kcl_val(&arg.value).ok_or_else(|| {
+            let expected_type_name = tynm::type_name::<T>();
+            let actual_type_name = arg.value.human_friendly_type();
+            let msg_base = format!("This function expected this argument to be of type {expected_type_name} but it's actually of type {actual_type_name}");
+            let suggestion = match (expected_type_name.as_str(), actual_type_name) {
+                ("SolidSet", "Sketch") => Some(
+                    "You can convert a sketch (2D) into a Solid (3D) by calling a function like `extrude` or `revolve`",
+                ),
+                _ => None,
+            };
+            let message = match suggestion {
+                None => msg_base,
+                Some(sugg) => format!("{msg_base}. {sugg}"),
+            };
             KclError::Semantic(KclErrorDetails {
                 source_ranges: arg.source_ranges(),
-                message: format!(
-                    "Expected a {} but found {}",
-                    type_name::<T>(),
-                    arg.value.human_friendly_type()
-                ),
+                message,
             })
         })
     }
@@ -1278,6 +1330,16 @@ impl<'a> FromKclValue<'a> for crate::execution::Solid {
     }
 }
 
+impl<'a> FromKclValue<'a> for crate::execution::SolidOrImportedGeometry {
+    fn from_kcl_val(arg: &'a KclValue) -> Option<Self> {
+        match arg {
+            KclValue::Solid { value } => Some(Self::Solid(value.clone())),
+            KclValue::ImportedGeometry(value) => Some(Self::ImportedGeometry(Box::new(value.clone()))),
+            _ => None,
+        }
+    }
+}
+
 impl<'a> FromKclValue<'a> for super::sketch::SketchData {
     fn from_kcl_val(arg: &'a KclValue) -> Option<Self> {
         // Order is critical since PlaneData is a subset of Plane.

rust/kcl-lib/src/std/chamfer.rs

@@ -5,7 +5,6 @@ use kcl_derive_docs::stdlib;
 use kcmc::{each_cmd as mcmd, length_unit::LengthUnit, shared::CutType, ModelingCmd};
 use kittycad_modeling_cmds as kcmc;
 
-use super::utils::unique_count;
 use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{ChamferSurface, EdgeCut, ExecState, ExtrudeSurface, GeoMeta, KclValue, Solid},
@@ -19,9 +18,11 @@ pub(crate) const DEFAULT_TOLERANCE: f64 = 0.0000001;
 pub async fn chamfer(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
     let solid = args.get_unlabeled_kw_arg("solid")?;
     let length = args.get_kw_arg("length")?;
-    let tags = args.get_kw_arg("tags")?;
+    let tags = args.kw_arg_array_and_source::<EdgeReference>("tags")?;
     let tag = args.get_kw_arg_opt("tag")?;
 
+    super::fillet::validate_unique(&tags)?;
+    let tags: Vec<EdgeReference> = tags.into_iter().map(|item| item.0).collect();
     let value = inner_chamfer(solid, length, tags, tag, exec_state, args).await?;
     Ok(KclValue::Solid { value })
 }
@@ -109,15 +110,6 @@ async fn inner_chamfer(
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Box<Solid>, KclError> {
-    // Check if tags contains any duplicate values.
-    let unique_tags = unique_count(tags.clone());
-    if unique_tags != tags.len() {
-        return Err(KclError::Type(KclErrorDetails {
-            message: "Duplicate tags are not allowed.".to_string(),
-            source_ranges: vec![args.source_range],
-        }));
-    }
-
     // If you try and tag multiple edges with a tagged chamfer, we want to return an
     // error to the user that they can only tag one edge at a time.
     if tag.is_some() && tags.len() > 1 {

rust/kcl-lib/src/std/fillet.rs

@@ -1,6 +1,7 @@
 //! Standard library fillets.
 
 use anyhow::Result;
+use indexmap::IndexMap;
 use kcl_derive_docs::stdlib;
 use kcmc::{
     each_cmd as mcmd, length_unit::LengthUnit, ok_response::OkModelingCmdResponse, shared::CutType,
@@ -11,13 +12,13 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use super::utils::unique_count;
 use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{EdgeCut, ExecState, ExtrudeSurface, FilletSurface, GeoMeta, KclValue, Solid, TagIdentifier},
     parsing::ast::types::TagNode,
     settings::types::UnitLength,
     std::Args,
+    SourceRange,
 };
 
 /// A tag or a uuid of an edge.
@@ -40,13 +41,39 @@ impl EdgeReference {
     }
 }
 
+pub(super) fn validate_unique<T: Eq + std::hash::Hash>(tags: &[(T, SourceRange)]) -> Result<(), KclError> {
+    // Check if tags contains any duplicate values.
+    let mut tag_counts: IndexMap<&T, Vec<SourceRange>> = Default::default();
+    for tag in tags {
+        tag_counts.entry(&tag.0).or_insert(Vec::new()).push(tag.1);
+    }
+    let mut duplicate_tags_source = Vec::new();
+    for (_tag, count) in tag_counts {
+        if count.len() > 1 {
+            duplicate_tags_source.extend(count)
+        }
+    }
+    if !duplicate_tags_source.is_empty() {
+        return Err(KclError::Type(KclErrorDetails {
+            message: "The same edge ID is being referenced multiple times, which is not allowed. Please select a different edge".to_string(),
+            source_ranges: duplicate_tags_source,
+        }));
+    }
+    Ok(())
+}
+
 /// Create fillets on tagged paths.
 pub async fn fillet(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+    // Get all args:
     let solid = args.get_unlabeled_kw_arg("solid")?;
     let radius = args.get_kw_arg("radius")?;
     let tolerance = args.get_kw_arg_opt("tolerance")?;
-    let tags = args.get_kw_arg("tags")?;
+    let tags = args.kw_arg_array_and_source::<EdgeReference>("tags")?;
     let tag = args.get_kw_arg_opt("tag")?;
+
+    // Run the function.
+    validate_unique(&tags)?;
+    let tags: Vec<EdgeReference> = tags.into_iter().map(|item| item.0).collect();
     let value = inner_fillet(solid, radius, tags, tolerance, tag, exec_state, args).await?;
     Ok(KclValue::Solid { value })
 }
@@ -129,15 +156,6 @@ async fn inner_fillet(
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Box<Solid>, KclError> {
-    // Check if tags contains any duplicate values.
-    let unique_tags = unique_count(tags.clone());
-    if unique_tags != tags.len() {
-        return Err(KclError::Type(KclErrorDetails {
-            message: "Duplicate tags are not allowed.".to_string(),
-            source_ranges: vec![args.source_range],
-        }));
-    }
-
     let mut solid = solid.clone();
     for edge_tag in tags {
         let edge_id = edge_tag.get_engine_id(exec_state, &args)?;
@@ -432,3 +450,22 @@ pub(crate) fn default_tolerance(units: &UnitLength) -> f64 {
         UnitLength::M => 0.001,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_unique() {
+        let dup_a = SourceRange::from([1, 3, 0]);
+        let dup_b = SourceRange::from([10, 30, 0]);
+        // Two entries are duplicates (abc) with different source ranges.
+        let tags = vec![("abc", dup_a), ("abc", dup_b), ("def", SourceRange::from([2, 4, 0]))];
+        let actual = validate_unique(&tags);
+        // Both the duplicates should show up as errors, with both of the
+        // source ranges they correspond to.
+        // But the unique source range 'def' should not.
+        let expected = vec![dup_a, dup_b];
+        assert_eq!(actual.err().unwrap().source_ranges(), expected);
+    }
+}

rust/kcl-lib/src/std/transform.rs

@@ -13,7 +13,7 @@ use kittycad_modeling_cmds as kcmc;
 
 use crate::{
     errors::{KclError, KclErrorDetails},
-    execution::{ExecState, KclValue, Solid},
+    execution::{ExecState, KclValue, SolidOrImportedGeometry},
     std::Args,
 };
 
@@ -24,7 +24,7 @@ pub async fn scale(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
     let global = args.get_kw_arg_opt("global")?;
 
     let solid = inner_scale(solid, scale, global, exec_state, args).await?;
-    Ok(KclValue::Solid { value: solid })
+    Ok(solid.into())
 }
 
 /// Scale a solid.
@@ -73,6 +73,17 @@ pub async fn scale(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 ///     scale = [1.0, 1.0, 2.5],
 ///     )
 /// ```
+///
+/// ```no_run
+/// // Scale an imported model.
+///
+/// import "tests/inputs/cube.sldprt" as cube
+///
+/// cube
+///     |> scale(
+///     scale = [1.0, 1.0, 2.5],
+///     )
+/// ```
 #[stdlib {
     name = "scale",
     feature_tree_operation = false,
@@ -85,18 +96,18 @@ pub async fn scale(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
     }
 }]
 async fn inner_scale(
-    solid: Box<Solid>,
+    solid: SolidOrImportedGeometry,
     scale: [f64; 3],
     global: Option<bool>,
     exec_state: &mut ExecState,
     args: Args,
-) -> Result<Box<Solid>, KclError> {
+) -> Result<SolidOrImportedGeometry, KclError> {
     let id = exec_state.next_uuid();
 
     args.batch_modeling_cmd(
         id,
         ModelingCmd::from(mcmd::SetObjectTransform {
-            object_id: solid.id,
+            object_id: solid.id(),
             transforms: vec![shared::ComponentTransform {
                 scale: Some(shared::TransformBy::<Point3d<f64>> {
                     property: Point3d {
@@ -125,7 +136,7 @@ pub async fn translate(exec_state: &mut ExecState, args: Args) -> Result<KclValu
     let global = args.get_kw_arg_opt("global")?;
 
     let solid = inner_translate(solid, translate, global, exec_state, args).await?;
-    Ok(KclValue::Solid { value: solid })
+    Ok(solid.into())
 }
 
 /// Move a solid.
@@ -166,6 +177,17 @@ pub async fn translate(exec_state: &mut ExecState, args: Args) -> Result<KclValu
 ///     translate = [1.0, 1.0, 2.5],
 ///     )
 /// ```
+///
+/// ```no_run
+/// // Move an imported model.
+///
+/// import "tests/inputs/cube.sldprt" as cube
+///
+/// cube
+///     |> translate(
+///     translate = [1.0, 1.0, 2.5],
+///     )
+/// ```
 #[stdlib {
     name = "translate",
     feature_tree_operation = false,
@@ -178,18 +200,18 @@ pub async fn translate(exec_state: &mut ExecState, args: Args) -> Result<KclValu
     }
 }]
 async fn inner_translate(
-    solid: Box<Solid>,
+    solid: SolidOrImportedGeometry,
     translate: [f64; 3],
     global: Option<bool>,
     exec_state: &mut ExecState,
     args: Args,
-) -> Result<Box<Solid>, KclError> {
+) -> Result<SolidOrImportedGeometry, KclError> {
     let id = exec_state.next_uuid();
 
     args.batch_modeling_cmd(
         id,
         ModelingCmd::from(mcmd::SetObjectTransform {
-            object_id: solid.id,
+            object_id: solid.id(),
             transforms: vec![shared::ComponentTransform {
                 translate: Some(shared::TransformBy::<Point3d<LengthUnit>> {
                     property: shared::Point3d {
@@ -322,7 +344,7 @@ pub async fn rotate(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
     }
 
     let solid = inner_rotate(solid, roll, pitch, yaw, axis, angle, global, exec_state, args).await?;
-    Ok(KclValue::Solid { value: solid })
+    Ok(solid.into())
 }
 
 /// Rotate a solid.
@@ -425,6 +447,18 @@ pub async fn rotate(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 ///     angle = 90,
 ///     )
 /// ```
+///
+/// ```no_run
+/// // Rotate an imported model.
+///
+/// import "tests/inputs/cube.sldprt" as cube
+///
+/// cube
+///     |> rotate(
+///     axis =  [0, 0, 1.0],
+///     angle = 90,
+///     )
+/// ```
 #[stdlib {
     name = "rotate",
     feature_tree_operation = false,
@@ -442,7 +476,7 @@ pub async fn rotate(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 }]
 #[allow(clippy::too_many_arguments)]
 async fn inner_rotate(
-    solid: Box<Solid>,
+    solid: SolidOrImportedGeometry,
     roll: Option<f64>,
     pitch: Option<f64>,
     yaw: Option<f64>,
@@ -451,14 +485,14 @@ async fn inner_rotate(
     global: Option<bool>,
     exec_state: &mut ExecState,
     args: Args,
-) -> Result<Box<Solid>, KclError> {
+) -> Result<SolidOrImportedGeometry, KclError> {
     let id = exec_state.next_uuid();
 
     if let (Some(roll), Some(pitch), Some(yaw)) = (roll, pitch, yaw) {
         args.batch_modeling_cmd(
             id,
             ModelingCmd::from(mcmd::SetObjectTransform {
-                object_id: solid.id,
+                object_id: solid.id(),
                 transforms: vec![shared::ComponentTransform {
                     rotate_rpy: Some(shared::TransformBy::<Point3d<f64>> {
                         property: shared::Point3d {
@@ -482,7 +516,7 @@ async fn inner_rotate(
         args.batch_modeling_cmd(
             id,
             ModelingCmd::from(mcmd::SetObjectTransform {
-                object_id: solid.id,
+                object_id: solid.id(),
                 transforms: vec![shared::ComponentTransform {
                     rotate_angle_axis: Some(shared::TransformBy::<Point4d<f64>> {
                         property: shared::Point4d {

rust/kcl-lib/src/std/utils.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashSet, f64::consts::PI};
+use std::f64::consts::PI;
 
 use kittycad_modeling_cmds::shared::Angle;
 
@@ -8,16 +8,6 @@ use crate::{
     source_range::SourceRange,
 };
 
-/// Count the number of unique items in a `Vec` in O(n) time.
-pub(crate) fn unique_count<T: Eq + std::hash::Hash>(vec: Vec<T>) -> usize {
-    // Add to a set.
-    let mut set = HashSet::with_capacity(vec.len());
-    for item in vec {
-        set.insert(item);
-    }
-    set.len()
-}
-
 /// Get the distance between two points.
 pub fn distance(a: Point2d, b: Point2d) -> f64 {
     ((b.x - a.x).powi(2) + (b.y - a.y).powi(2)).sqrt()
@@ -686,11 +676,6 @@ mod get_tangential_arc_to_info_tests {
         (num * 1000.0).round() / 1000.0
     }
 
-    #[test]
-    fn test_unique_count() {
-        assert_eq!(unique_count(vec![1, 2, 2, 3, 2]), 3);
-    }
-
     #[test]
     fn test_basic_case() {
         let result = get_tangential_arc_to_info(TangentialArcInfoInput {

rust/kcl-lib/tests/array_elem_pop/ast.snap

@@ -1,5 +1,5 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Result of parsing array_elem_pop.kcl
 ---
 {

rust/kcl-lib/tests/array_elem_pop_empty_fail/ast.snap

@@ -1,5 +1,5 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Result of parsing array_elem_pop_empty_fail.kcl
 ---
 {

rust/kcl-lib/tests/array_elem_pop_empty_fail/execution_error.snap

@@ -1,5 +1,5 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Error from executing array_elem_pop_empty_fail.kcl
 ---
 KCL Semantic error

rust/kcl-lib/tests/import_transform/artifact_graph_flowchart.snap

@@ -0,0 +1,6 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Artifact graph flowchart import_transform.kcl
+extension: md
+snapshot_kind: binary
+---

rust/kcl-lib/tests/import_transform/artifact_graph_flowchart.snap.md

@@ -0,0 +1,3 @@
+```mermaid
+flowchart LR
+```

rust/kcl-lib/tests/import_transform/ast.snap

@@ -0,0 +1,287 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Result of parsing import_transform.kcl
+---
+{
+  "Ok": {
+    "body": [
+      {
+        "end": 43,
+        "path": {
+          "type": "Foreign",
+          "path": "2-5-long-m8-chc-screw.stl"
+        },
+        "selector": {
+          "type": "None",
+          "alias": {
+            "end": 43,
+            "name": "screw",
+            "start": 38,
+            "type": "Identifier"
+          }
+        },
+        "start": 0,
+        "type": "ImportStatement",
+        "type": "ImportStatement"
+      },
+      {
+        "end": 232,
+        "expression": {
+          "body": [
+            {
+              "end": 50,
+              "name": "screw",
+              "start": 45,
+              "type": "Identifier",
+              "type": "Identifier"
+            },
+            {
+              "arguments": [
+                {
+                  "type": "LabeledArg",
+                  "label": {
+                    "end": 85,
+                    "name": "roll",
+                    "start": 81,
+                    "type": "Identifier"
+                  },
+                  "arg": {
+                    "end": 92,
+                    "raw": "3.14",
+                    "start": 88,
+                    "type": "Literal",
+                    "type": "Literal",
+                    "value": {
+                      "value": 3.14,
+                      "suffix": "None"
+                    }
+                  }
+                },
+                {
+                  "type": "LabeledArg",
+                  "label": {
+                    "end": 106,
+                    "name": "pitch",
+                    "start": 101,
+                    "type": "Identifier"
+                  },
+                  "arg": {
+                    "end": 113,
+                    "raw": "3.14",
+                    "start": 109,
+                    "type": "Literal",
+                    "type": "Literal",
+                    "value": {
+                      "value": 3.14,
+                      "suffix": "None"
+                    }
+                  }
+                },
+                {
+                  "type": "LabeledArg",
+                  "label": {
+                    "end": 125,
+                    "name": "yaw",
+                    "start": 122,
+                    "type": "Identifier"
+                  },
+                  "arg": {
+                    "end": 132,
+                    "raw": "3.14",
+                    "start": 128,
+                    "type": "Literal",
+                    "type": "Literal",
+                    "value": {
+                      "value": 3.14,
+                      "suffix": "None"
+                    }
+                  }
+                }
+              ],
+              "callee": {
+                "end": 62,
+                "name": "rotate",
+                "start": 56,
+                "type": "Identifier"
+              },
+              "end": 140,
+              "start": 56,
+              "type": "CallExpressionKw",
+              "type": "CallExpressionKw",
+              "unlabeled": {
+                "end": 72,
+                "start": 71,
+                "type": "PipeSubstitution",
+                "type": "PipeSubstitution"
+              }
+            },
+            {
+              "arguments": [
+                {
+                  "type": "LabeledArg",
+                  "label": {
+                    "end": 168,
+                    "name": "translate",
+                    "start": 159,
+                    "type": "Identifier"
+                  },
+                  "arg": {
+                    "elements": [
+                      {
+                        "end": 176,
+                        "raw": "3.14",
+                        "start": 172,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      },
+                      {
+                        "end": 182,
+                        "raw": "3.14",
+                        "start": 178,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      },
+                      {
+                        "end": 188,
+                        "raw": "3.14",
+                        "start": 184,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      }
+                    ],
+                    "end": 189,
+                    "start": 171,
+                    "type": "ArrayExpression",
+                    "type": "ArrayExpression"
+                  }
+                }
+              ],
+              "callee": {
+                "end": 155,
+                "name": "translate",
+                "start": 146,
+                "type": "Identifier"
+              },
+              "end": 190,
+              "start": 146,
+              "type": "CallExpressionKw",
+              "type": "CallExpressionKw",
+              "unlabeled": {
+                "end": 157,
+                "start": 156,
+                "type": "PipeSubstitution",
+                "type": "PipeSubstitution"
+              }
+            },
+            {
+              "arguments": [
+                {
+                  "type": "LabeledArg",
+                  "label": {
+                    "end": 210,
+                    "name": "scale",
+                    "start": 205,
+                    "type": "Identifier"
+                  },
+                  "arg": {
+                    "elements": [
+                      {
+                        "end": 218,
+                        "raw": "3.14",
+                        "start": 214,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      },
+                      {
+                        "end": 224,
+                        "raw": "3.14",
+                        "start": 220,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      },
+                      {
+                        "end": 230,
+                        "raw": "3.14",
+                        "start": 226,
+                        "type": "Literal",
+                        "type": "Literal",
+                        "value": {
+                          "value": 3.14,
+                          "suffix": "None"
+                        }
+                      }
+                    ],
+                    "end": 231,
+                    "start": 213,
+                    "type": "ArrayExpression",
+                    "type": "ArrayExpression"
+                  }
+                }
+              ],
+              "callee": {
+                "end": 201,
+                "name": "scale",
+                "start": 196,
+                "type": "Identifier"
+              },
+              "end": 232,
+              "start": 196,
+              "type": "CallExpressionKw",
+              "type": "CallExpressionKw",
+              "unlabeled": {
+                "end": 203,
+                "start": 202,
+                "type": "PipeSubstitution",
+                "type": "PipeSubstitution"
+              }
+            }
+          ],
+          "end": 232,
+          "start": 45,
+          "type": "PipeExpression",
+          "type": "PipeExpression"
+        },
+        "start": 45,
+        "type": "ExpressionStatement",
+        "type": "ExpressionStatement"
+      }
+    ],
+    "end": 233,
+    "nonCodeMeta": {
+      "nonCodeNodes": {
+        "0": [
+          {
+            "end": 45,
+            "start": 43,
+            "type": "NonCodeNode",
+            "value": {
+              "type": "newLine"
+            }
+          }
+        ]
+      },
+      "startNodes": []
+    },
+    "start": 0
+  }
+}

rust/kcl-lib/tests/import_transform/input.kcl

@@ -0,0 +1,11 @@
+import "2-5-long-m8-chc-screw.stl" as screw
+
+screw
+  |> rotate(
+       %,
+       roll = 3.14,
+       pitch = 3.14,
+       yaw = 3.14,
+     )
+  |> translate(%, translate = [3.14, 3.14, 3.14])
+  |> scale(%, scale = [3.14, 3.14, 3.14])

rust/kcl-lib/tests/import_transform/ops.snap

@@ -0,0 +1,5 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Operations executed import_transform.kcl
+---
+[]

rust/kcl-lib/tests/import_transform/program_memory.snap

@@ -0,0 +1,19 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Variables in memory after executing import_transform.kcl
+---
+{
+  "screw": {
+    "type": "Module",
+    "value": 3,
+    "__meta": [
+      {
+        "sourceRange": [
+          0,
+          43,
+          0
+        ]
+      }
+    ]
+  }
+}

rust/kcl-lib/tests/kcl_samples/a-parametric-bearing-pillow-block/exported_step.macos.step

@@ -1,713 +0,0 @@
-ISO-10303-21;
-HEADER;
-FILE_DESCRIPTION((('zoo.dev export')), '2;1');
-FILE_NAME('test.step', '2021-01-01T00:00:00Z', ('Test'), ('Zoo'), 'zoo.dev beta', 'zoo.dev', 'Test');
-FILE_SCHEMA(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF'));
-ENDSEC;
-DATA;
-#1 = (
-  LENGTH_UNIT()
-  NAMED_UNIT(*)
-  SI_UNIT($, .METRE.)
-);
-#2 = UNCERTAINTY_MEASURE_WITH_UNIT(0.00001, #1, 'DISTANCE_ACCURACY_VALUE', $);
-#3 = (
-  GEOMETRIC_REPRESENTATION_CONTEXT(3)
-  GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#2))
-  GLOBAL_UNIT_ASSIGNED_CONTEXT((#1))
-  REPRESENTATION_CONTEXT('', '3D')
-);
-#4 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, 0.0762));
-#5 = VERTEX_POINT('NONE', #4);
-#6 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, 0.0762));
-#7 = VERTEX_POINT('NONE', #6);
-#8 = CARTESIAN_POINT('NONE', (0.0508, 0.0254, 0.0762));
-#9 = VERTEX_POINT('NONE', #8);
-#10 = CARTESIAN_POINT('NONE', (-0.0508, 0.0254, 0.0762));
-#11 = VERTEX_POINT('NONE', #10);
-#12 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, -0.0762));
-#13 = VERTEX_POINT('NONE', #12);
-#14 = CARTESIAN_POINT('NONE', (0.0508, 0.0254, -0.0762));
-#15 = VERTEX_POINT('NONE', #14);
-#16 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, -0.0762));
-#17 = VERTEX_POINT('NONE', #16);
-#18 = CARTESIAN_POINT('NONE', (-0.0508, 0.0254, -0.0762));
-#19 = VERTEX_POINT('NONE', #18);
-#20 = CARTESIAN_POINT('NONE', (-0.02286, 0.01905, 0.05715));
-#21 = VERTEX_POINT('NONE', #20);
-#22 = CARTESIAN_POINT('NONE', (-0.02286, 0.0254, 0.05715));
-#23 = VERTEX_POINT('NONE', #22);
-#24 = CARTESIAN_POINT('NONE', (-0.02286, 0.01905, -0.05715));
-#25 = VERTEX_POINT('NONE', #24);
-#26 = CARTESIAN_POINT('NONE', (-0.02286, 0.0254, -0.05715));
-#27 = VERTEX_POINT('NONE', #26);
-#28 = CARTESIAN_POINT('NONE', (0.04064, 0.01905, -0.05715));
-#29 = VERTEX_POINT('NONE', #28);
-#30 = CARTESIAN_POINT('NONE', (0.04064, 0.0254, -0.05715));
-#31 = VERTEX_POINT('NONE', #30);
-#32 = CARTESIAN_POINT('NONE', (0.04064, 0.01905, 0.05715));
-#33 = VERTEX_POINT('NONE', #32);
-#34 = CARTESIAN_POINT('NONE', (0.04064, 0.0254, 0.05715));
-#35 = VERTEX_POINT('NONE', #34);
-#36 = CARTESIAN_POINT('NONE', (0.0381, 0.01905, 0.000000000000000009331808609502833));
-#37 = VERTEX_POINT('NONE', #36);
-#38 = CARTESIAN_POINT('NONE', (0.0381, 0.0254, 0.000000000000000009331808609502833));
-#39 = VERTEX_POINT('NONE', #38);
-#40 = CARTESIAN_POINT('NONE', (-0.0508, 0, 0.0762));
-#41 = VERTEX_POINT('NONE', #40);
-#42 = CARTESIAN_POINT('NONE', (0.0508, 0, 0.0762));
-#43 = VERTEX_POINT('NONE', #42);
-#44 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, 0.0762));
-#45 = VERTEX_POINT('NONE', #44);
-#46 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, 0.0762));
-#47 = VERTEX_POINT('NONE', #46);
-#48 = CARTESIAN_POINT('NONE', (0.0508, 0, -0.0762));
-#49 = VERTEX_POINT('NONE', #48);
-#50 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, -0.0762));
-#51 = VERTEX_POINT('NONE', #50);
-#52 = CARTESIAN_POINT('NONE', (-0.0508, 0, -0.0762));
-#53 = VERTEX_POINT('NONE', #52);
-#54 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, -0.0762));
-#55 = VERTEX_POINT('NONE', #54);
-#56 = CARTESIAN_POINT('NONE', (-0.0269875, 0, 0.05715));
-#57 = VERTEX_POINT('NONE', #56);
-#58 = CARTESIAN_POINT('NONE', (-0.0269875, 0.01905, 0.05715));
-#59 = VERTEX_POINT('NONE', #58);
-#60 = CARTESIAN_POINT('NONE', (-0.0269875, 0, -0.05715));
-#61 = VERTEX_POINT('NONE', #60);
-#62 = CARTESIAN_POINT('NONE', (-0.0269875, 0.01905, -0.05715));
-#63 = VERTEX_POINT('NONE', #62);
-#64 = CARTESIAN_POINT('NONE', (0.0365125, 0, -0.05715));
-#65 = VERTEX_POINT('NONE', #64);
-#66 = CARTESIAN_POINT('NONE', (0.0365125, 0.01905, -0.05715));
-#67 = VERTEX_POINT('NONE', #66);
-#68 = CARTESIAN_POINT('NONE', (0.0365125, 0, 0.05715));
-#69 = VERTEX_POINT('NONE', #68);
-#70 = CARTESIAN_POINT('NONE', (0.0365125, 0.01905, 0.05715));
-#71 = VERTEX_POINT('NONE', #70);
-#72 = CARTESIAN_POINT('NONE', (0.0381, 0, 0.000000000000000009331808609502833));
-#73 = VERTEX_POINT('NONE', #72);
-#74 = CARTESIAN_POINT('NONE', (0.0381, 0.01905, 0.000000000000000009331808609502833));
-#75 = VERTEX_POINT('NONE', #74);
-#76 = DIRECTION('NONE', (1, 0, 0));
-#77 = VECTOR('NONE', #76, 1);
-#78 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, 0.0762));
-#79 = LINE('NONE', #78, #77);
-#80 = DIRECTION('NONE', (0, 1, 0));
-#81 = VECTOR('NONE', #80, 1);
-#82 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, 0.0762));
-#83 = LINE('NONE', #82, #81);
-#84 = DIRECTION('NONE', (1, 0, 0));
-#85 = VECTOR('NONE', #84, 1);
-#86 = CARTESIAN_POINT('NONE', (-0.0508, 0.0254, 0.0762));
-#87 = LINE('NONE', #86, #85);
-#88 = DIRECTION('NONE', (0, 1, 0));
-#89 = VECTOR('NONE', #88, 1);
-#90 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, 0.0762));
-#91 = LINE('NONE', #90, #89);
-#92 = DIRECTION('NONE', (0, 0, -1));
-#93 = VECTOR('NONE', #92, 1);
-#94 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, 0.0762));
-#95 = LINE('NONE', #94, #93);
-#96 = DIRECTION('NONE', (0, 1, 0));
-#97 = VECTOR('NONE', #96, 1);
-#98 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, -0.0762));
-#99 = LINE('NONE', #98, #97);
-#100 = DIRECTION('NONE', (0, 0, -1));
-#101 = VECTOR('NONE', #100, 1);
-#102 = CARTESIAN_POINT('NONE', (0.0508, 0.0254, 0.0762));
-#103 = LINE('NONE', #102, #101);
-#104 = DIRECTION('NONE', (-1, 0, 0));
-#105 = VECTOR('NONE', #104, 1);
-#106 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, -0.0762));
-#107 = LINE('NONE', #106, #105);
-#108 = DIRECTION('NONE', (0, 1, 0));
-#109 = VECTOR('NONE', #108, 1);
-#110 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, -0.0762));
-#111 = LINE('NONE', #110, #109);
-#112 = DIRECTION('NONE', (-1, 0, 0));
-#113 = VECTOR('NONE', #112, 1);
-#114 = CARTESIAN_POINT('NONE', (0.0508, 0.0254, -0.0762));
-#115 = LINE('NONE', #114, #113);
-#116 = DIRECTION('NONE', (0, 0, 1));
-#117 = VECTOR('NONE', #116, 1);
-#118 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, -0.0762));
-#119 = LINE('NONE', #118, #117);
-#120 = DIRECTION('NONE', (0, 0, 1));
-#121 = VECTOR('NONE', #120, 1);
-#122 = CARTESIAN_POINT('NONE', (-0.0508, 0.0254, -0.0762));
-#123 = LINE('NONE', #122, #121);
-#124 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463443));
-#125 = DIRECTION('NONE', (0, -1, 0));
-#126 = CARTESIAN_POINT('NONE', (-0.03175, 0.01905, 0.05714999999999999));
-#127 = AXIS2_PLACEMENT_3D('NONE', #126, #125, #124);
-#128 = CIRCLE('NONE', #127, 0.00889);
-#129 = DIRECTION('NONE', (0, 1, 0));
-#130 = VECTOR('NONE', #129, 1);
-#131 = CARTESIAN_POINT('NONE', (-0.02286, 0.01905, 0.05715));
-#132 = LINE('NONE', #131, #130);
-#133 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463443));
-#134 = DIRECTION('NONE', (0, -1, 0));
-#135 = CARTESIAN_POINT('NONE', (-0.03175, 0.0254, 0.05714999999999999));
-#136 = AXIS2_PLACEMENT_3D('NONE', #135, #134, #133);
-#137 = CIRCLE('NONE', #136, 0.00889);
-#138 = DIRECTION('NONE', (1, 0, -0.0000000000000007992606701463447));
-#139 = DIRECTION('NONE', (0, -1, 0));
-#140 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.01905, -0.05714999999999999));
-#141 = AXIS2_PLACEMENT_3D('NONE', #140, #139, #138);
-#142 = CIRCLE('NONE', #141, 0.008889999999999997);
-#143 = DIRECTION('NONE', (0, 1, 0));
-#144 = VECTOR('NONE', #143, 1);
-#145 = CARTESIAN_POINT('NONE', (-0.02286, 0.01905, -0.05715));
-#146 = LINE('NONE', #145, #144);
-#147 = DIRECTION('NONE', (1, 0, -0.0000000000000007992606701463447));
-#148 = DIRECTION('NONE', (0, -1, 0));
-#149 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.0254, -0.05714999999999999));
-#150 = AXIS2_PLACEMENT_3D('NONE', #149, #148, #147);
-#151 = CIRCLE('NONE', #150, 0.008889999999999997);
-#152 = DIRECTION('NONE', (1, 0, -0.000000000000000799260670146344));
-#153 = DIRECTION('NONE', (0, -1, 0));
-#154 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.01905, -0.05714999999999999));
-#155 = AXIS2_PLACEMENT_3D('NONE', #154, #153, #152);
-#156 = CIRCLE('NONE', #155, 0.008890000000000004);
-#157 = DIRECTION('NONE', (0, 1, 0));
-#158 = VECTOR('NONE', #157, 1);
-#159 = CARTESIAN_POINT('NONE', (0.04064, 0.01905, -0.05715));
-#160 = LINE('NONE', #159, #158);
-#161 = DIRECTION('NONE', (1, 0, -0.000000000000000799260670146344));
-#162 = DIRECTION('NONE', (0, -1, 0));
-#163 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.0254, -0.05714999999999999));
-#164 = AXIS2_PLACEMENT_3D('NONE', #163, #162, #161);
-#165 = CIRCLE('NONE', #164, 0.008890000000000004);
-#166 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463447));
-#167 = DIRECTION('NONE', (0, -1, 0));
-#168 = CARTESIAN_POINT('NONE', (0.03175, 0.01905, 0.05714999999999999));
-#169 = AXIS2_PLACEMENT_3D('NONE', #168, #167, #166);
-#170 = CIRCLE('NONE', #169, 0.008889999999999997);
-#171 = DIRECTION('NONE', (0, 1, 0));
-#172 = VECTOR('NONE', #171, 1);
-#173 = CARTESIAN_POINT('NONE', (0.04064, 0.01905, 0.05715));
-#174 = LINE('NONE', #173, #172);
-#175 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463447));
-#176 = DIRECTION('NONE', (0, -1, 0));
-#177 = CARTESIAN_POINT('NONE', (0.03175, 0.0254, 0.05714999999999999));
-#178 = AXIS2_PLACEMENT_3D('NONE', #177, #176, #175);
-#179 = CIRCLE('NONE', #178, 0.008889999999999997);
-#180 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#181 = DIRECTION('NONE', (0, -1, 0));
-#182 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, 0.01905, -0.000000000000000000000000000000000418356671621052));
-#183 = AXIS2_PLACEMENT_3D('NONE', #182, #181, #180);
-#184 = CIRCLE('NONE', #183, 0.0381);
-#185 = DIRECTION('NONE', (0, 1, 0));
-#186 = VECTOR('NONE', #185, 1);
-#187 = CARTESIAN_POINT('NONE', (0.0381, 0.01905, 0.000000000000000009331808609502833));
-#188 = LINE('NONE', #187, #186);
-#189 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#190 = DIRECTION('NONE', (0, -1, 0));
-#191 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, 0.0254, -0.000000000000000000000000000000000418356671621052));
-#192 = AXIS2_PLACEMENT_3D('NONE', #191, #190, #189);
-#193 = CIRCLE('NONE', #192, 0.0381);
-#194 = DIRECTION('NONE', (1, 0, 0));
-#195 = VECTOR('NONE', #194, 1);
-#196 = CARTESIAN_POINT('NONE', (-0.0508, 0, 0.0762));
-#197 = LINE('NONE', #196, #195);
-#198 = DIRECTION('NONE', (0, 1, 0));
-#199 = VECTOR('NONE', #198, 1);
-#200 = CARTESIAN_POINT('NONE', (0.0508, 0, 0.0762));
-#201 = LINE('NONE', #200, #199);
-#202 = DIRECTION('NONE', (1, 0, 0));
-#203 = VECTOR('NONE', #202, 1);
-#204 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, 0.0762));
-#205 = LINE('NONE', #204, #203);
-#206 = DIRECTION('NONE', (0, 1, 0));
-#207 = VECTOR('NONE', #206, 1);
-#208 = CARTESIAN_POINT('NONE', (-0.0508, 0, 0.0762));
-#209 = LINE('NONE', #208, #207);
-#210 = DIRECTION('NONE', (0, 0, -1));
-#211 = VECTOR('NONE', #210, 1);
-#212 = CARTESIAN_POINT('NONE', (0.0508, 0, 0.0762));
-#213 = LINE('NONE', #212, #211);
-#214 = DIRECTION('NONE', (0, 1, 0));
-#215 = VECTOR('NONE', #214, 1);
-#216 = CARTESIAN_POINT('NONE', (0.0508, 0, -0.0762));
-#217 = LINE('NONE', #216, #215);
-#218 = DIRECTION('NONE', (0, 0, -1));
-#219 = VECTOR('NONE', #218, 1);
-#220 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, 0.0762));
-#221 = LINE('NONE', #220, #219);
-#222 = DIRECTION('NONE', (-1, 0, 0));
-#223 = VECTOR('NONE', #222, 1);
-#224 = CARTESIAN_POINT('NONE', (0.0508, 0, -0.0762));
-#225 = LINE('NONE', #224, #223);
-#226 = DIRECTION('NONE', (0, 1, 0));
-#227 = VECTOR('NONE', #226, 1);
-#228 = CARTESIAN_POINT('NONE', (-0.0508, 0, -0.0762));
-#229 = LINE('NONE', #228, #227);
-#230 = DIRECTION('NONE', (-1, 0, 0));
-#231 = VECTOR('NONE', #230, 1);
-#232 = CARTESIAN_POINT('NONE', (0.0508, 0.01905, -0.0762));
-#233 = LINE('NONE', #232, #231);
-#234 = DIRECTION('NONE', (0, 0, 1));
-#235 = VECTOR('NONE', #234, 1);
-#236 = CARTESIAN_POINT('NONE', (-0.0508, 0, -0.0762));
-#237 = LINE('NONE', #236, #235);
-#238 = DIRECTION('NONE', (0, 0, 1));
-#239 = VECTOR('NONE', #238, 1);
-#240 = CARTESIAN_POINT('NONE', (-0.0508, 0.01905, -0.0762));
-#241 = LINE('NONE', #240, #239);
-#242 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#243 = DIRECTION('NONE', (0, -1, 0));
-#244 = CARTESIAN_POINT('NONE', (-0.031749999999999994, -0, 0.057150000000000006));
-#245 = AXIS2_PLACEMENT_3D('NONE', #244, #243, #242);
-#246 = CIRCLE('NONE', #245, 0.004762499999999996);
-#247 = DIRECTION('NONE', (0, 1, 0));
-#248 = VECTOR('NONE', #247, 1);
-#249 = CARTESIAN_POINT('NONE', (-0.0269875, 0, 0.05715));
-#250 = LINE('NONE', #249, #248);
-#251 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#252 = DIRECTION('NONE', (0, -1, 0));
-#253 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.01905, 0.057150000000000006));
-#254 = AXIS2_PLACEMENT_3D('NONE', #253, #252, #251);
-#255 = CIRCLE('NONE', #254, 0.004762499999999996);
-#256 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#257 = DIRECTION('NONE', (0, -1, 0));
-#258 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0, -0.05714999999999999));
-#259 = AXIS2_PLACEMENT_3D('NONE', #258, #257, #256);
-#260 = CIRCLE('NONE', #259, 0.004762499999999996);
-#261 = DIRECTION('NONE', (0, 1, 0));
-#262 = VECTOR('NONE', #261, 1);
-#263 = CARTESIAN_POINT('NONE', (-0.0269875, 0, -0.05715));
-#264 = LINE('NONE', #263, #262);
-#265 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#266 = DIRECTION('NONE', (0, -1, 0));
-#267 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.01905, -0.05714999999999999));
-#268 = AXIS2_PLACEMENT_3D('NONE', #267, #266, #265);
-#269 = CIRCLE('NONE', #268, 0.004762499999999996);
-#270 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#271 = DIRECTION('NONE', (0, -1, 0));
-#272 = CARTESIAN_POINT('NONE', (0.031749999999999994, -0, -0.05714999999999999));
-#273 = AXIS2_PLACEMENT_3D('NONE', #272, #271, #270);
-#274 = CIRCLE('NONE', #273, 0.004762500000000006);
-#275 = DIRECTION('NONE', (0, 1, 0));
-#276 = VECTOR('NONE', #275, 1);
-#277 = CARTESIAN_POINT('NONE', (0.0365125, 0, -0.05715));
-#278 = LINE('NONE', #277, #276);
-#279 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#280 = DIRECTION('NONE', (0, -1, 0));
-#281 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.01905, -0.05714999999999999));
-#282 = AXIS2_PLACEMENT_3D('NONE', #281, #280, #279);
-#283 = CIRCLE('NONE', #282, 0.004762500000000006);
-#284 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#285 = DIRECTION('NONE', (0, -1, 0));
-#286 = CARTESIAN_POINT('NONE', (0.031749999999999994, -0, 0.057150000000000006));
-#287 = AXIS2_PLACEMENT_3D('NONE', #286, #285, #284);
-#288 = CIRCLE('NONE', #287, 0.004762500000000006);
-#289 = DIRECTION('NONE', (0, 1, 0));
-#290 = VECTOR('NONE', #289, 1);
-#291 = CARTESIAN_POINT('NONE', (0.0365125, 0, 0.05715));
-#292 = LINE('NONE', #291, #290);
-#293 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#294 = DIRECTION('NONE', (0, -1, 0));
-#295 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.01905, 0.057150000000000006));
-#296 = AXIS2_PLACEMENT_3D('NONE', #295, #294, #293);
-#297 = CIRCLE('NONE', #296, 0.004762500000000006);
-#298 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#299 = DIRECTION('NONE', (0, -1, 0));
-#300 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, -0, -0.000000000000000000000000000000000418356671621052));
-#301 = AXIS2_PLACEMENT_3D('NONE', #300, #299, #298);
-#302 = CIRCLE('NONE', #301, 0.0381);
-#303 = DIRECTION('NONE', (0, 1, 0));
-#304 = VECTOR('NONE', #303, 1);
-#305 = CARTESIAN_POINT('NONE', (0.0381, 0, 0.000000000000000009331808609502833));
-#306 = LINE('NONE', #305, #304);
-#307 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#308 = DIRECTION('NONE', (0, -1, 0));
-#309 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, 0.01905, -0.000000000000000000000000000000000418356671621052));
-#310 = AXIS2_PLACEMENT_3D('NONE', #309, #308, #307);
-#311 = CIRCLE('NONE', #310, 0.0381);
-#312 = EDGE_CURVE('NONE', #5, #7, #79, .T.);
-#313 = EDGE_CURVE('NONE', #7, #9, #83, .T.);
-#314 = EDGE_CURVE('NONE', #11, #9, #87, .T.);
-#315 = EDGE_CURVE('NONE', #5, #11, #91, .T.);
-#316 = EDGE_CURVE('NONE', #7, #13, #95, .T.);
-#317 = EDGE_CURVE('NONE', #13, #15, #99, .T.);
-#318 = EDGE_CURVE('NONE', #9, #15, #103, .T.);
-#319 = EDGE_CURVE('NONE', #13, #17, #107, .T.);
-#320 = EDGE_CURVE('NONE', #17, #19, #111, .T.);
-#321 = EDGE_CURVE('NONE', #15, #19, #115, .T.);
-#322 = EDGE_CURVE('NONE', #17, #5, #119, .T.);
-#323 = EDGE_CURVE('NONE', #19, #11, #123, .T.);
-#324 = EDGE_CURVE('NONE', #21, #21, #128, .T.);
-#325 = EDGE_CURVE('NONE', #21, #23, #132, .T.);
-#326 = EDGE_CURVE('NONE', #23, #23, #137, .T.);
-#327 = EDGE_CURVE('NONE', #25, #25, #142, .T.);
-#328 = EDGE_CURVE('NONE', #25, #27, #146, .T.);
-#329 = EDGE_CURVE('NONE', #27, #27, #151, .T.);
-#330 = EDGE_CURVE('NONE', #29, #29, #156, .T.);
-#331 = EDGE_CURVE('NONE', #29, #31, #160, .T.);
-#332 = EDGE_CURVE('NONE', #31, #31, #165, .T.);
-#333 = EDGE_CURVE('NONE', #33, #33, #170, .T.);
-#334 = EDGE_CURVE('NONE', #33, #35, #174, .T.);
-#335 = EDGE_CURVE('NONE', #35, #35, #179, .T.);
-#336 = EDGE_CURVE('NONE', #37, #37, #184, .T.);
-#337 = EDGE_CURVE('NONE', #37, #39, #188, .T.);
-#338 = EDGE_CURVE('NONE', #39, #39, #193, .T.);
-#339 = EDGE_CURVE('NONE', #41, #43, #197, .T.);
-#340 = EDGE_CURVE('NONE', #43, #45, #201, .T.);
-#341 = EDGE_CURVE('NONE', #47, #45, #205, .T.);
-#342 = EDGE_CURVE('NONE', #41, #47, #209, .T.);
-#343 = EDGE_CURVE('NONE', #43, #49, #213, .T.);
-#344 = EDGE_CURVE('NONE', #49, #51, #217, .T.);
-#345 = EDGE_CURVE('NONE', #45, #51, #221, .T.);
-#346 = EDGE_CURVE('NONE', #49, #53, #225, .T.);
-#347 = EDGE_CURVE('NONE', #53, #55, #229, .T.);
-#348 = EDGE_CURVE('NONE', #51, #55, #233, .T.);
-#349 = EDGE_CURVE('NONE', #53, #41, #237, .T.);
-#350 = EDGE_CURVE('NONE', #55, #47, #241, .T.);
-#351 = EDGE_CURVE('NONE', #57, #57, #246, .T.);
-#352 = EDGE_CURVE('NONE', #57, #59, #250, .T.);
-#353 = EDGE_CURVE('NONE', #59, #59, #255, .T.);
-#354 = EDGE_CURVE('NONE', #61, #61, #260, .T.);
-#355 = EDGE_CURVE('NONE', #61, #63, #264, .T.);
-#356 = EDGE_CURVE('NONE', #63, #63, #269, .T.);
-#357 = EDGE_CURVE('NONE', #65, #65, #274, .T.);
-#358 = EDGE_CURVE('NONE', #65, #67, #278, .T.);
-#359 = EDGE_CURVE('NONE', #67, #67, #283, .T.);
-#360 = EDGE_CURVE('NONE', #69, #69, #288, .T.);
-#361 = EDGE_CURVE('NONE', #69, #71, #292, .T.);
-#362 = EDGE_CURVE('NONE', #71, #71, #297, .T.);
-#363 = EDGE_CURVE('NONE', #73, #73, #302, .T.);
-#364 = EDGE_CURVE('NONE', #73, #75, #306, .T.);
-#365 = EDGE_CURVE('NONE', #75, #75, #311, .T.);
-#366 = CARTESIAN_POINT('NONE', (0, 0.022224999999999995, 0.07619999999999999));
-#367 = DIRECTION('NONE', (0, 0, 1));
-#368 = AXIS2_PLACEMENT_3D('NONE', #366, #367, $);
-#369 = PLANE('NONE', #368);
-#370 = CARTESIAN_POINT('NONE', (0.0508, 0.022225, -0.000000000000000014210854715202004));
-#371 = DIRECTION('NONE', (1, -0, 0));
-#372 = AXIS2_PLACEMENT_3D('NONE', #370, #371, $);
-#373 = PLANE('NONE', #372);
-#374 = CARTESIAN_POINT('NONE', (0, 0.022225, -0.0762));
-#375 = DIRECTION('NONE', (0, -0, -1));
-#376 = AXIS2_PLACEMENT_3D('NONE', #374, #375, $);
-#377 = PLANE('NONE', #376);
-#378 = CARTESIAN_POINT('NONE', (-0.0508, 0.022225, -0));
-#379 = DIRECTION('NONE', (-1, 0, 0));
-#380 = AXIS2_PLACEMENT_3D('NONE', #378, #379, $);
-#381 = PLANE('NONE', #380);
-#382 = CARTESIAN_POINT('NONE', (-0.03175, 0.022225, 0.05714999999999999));
-#383 = DIRECTION('NONE', (0, -1, 0));
-#384 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463443));
-#385 = AXIS2_PLACEMENT_3D('NONE', #382, #383, #384);
-#386 = CYLINDRICAL_SURFACE('NONE', #385, 0.00889);
-#387 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.022225, -0.05714999999999999));
-#388 = DIRECTION('NONE', (0, -1, 0));
-#389 = DIRECTION('NONE', (1, 0, -0.0000000000000007992606701463447));
-#390 = AXIS2_PLACEMENT_3D('NONE', #387, #388, #389);
-#391 = CYLINDRICAL_SURFACE('NONE', #390, 0.008889999999999997);
-#392 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.022225, -0.05714999999999999));
-#393 = DIRECTION('NONE', (0, -1, 0));
-#394 = DIRECTION('NONE', (1, 0, -0.000000000000000799260670146344));
-#395 = AXIS2_PLACEMENT_3D('NONE', #392, #393, #394);
-#396 = CYLINDRICAL_SURFACE('NONE', #395, 0.008890000000000004);
-#397 = CARTESIAN_POINT('NONE', (0.03175, 0.022225, 0.05714999999999999));
-#398 = DIRECTION('NONE', (0, -1, 0));
-#399 = DIRECTION('NONE', (1, 0, 0.0000000000000007992606701463447));
-#400 = AXIS2_PLACEMENT_3D('NONE', #397, #398, #399);
-#401 = CYLINDRICAL_SURFACE('NONE', #400, 0.008889999999999997);
-#402 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, 0.022225, -0.000000000000000000000000000000000418356671621052));
-#403 = DIRECTION('NONE', (0, -1, 0));
-#404 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#405 = AXIS2_PLACEMENT_3D('NONE', #402, #403, #404);
-#406 = CYLINDRICAL_SURFACE('NONE', #405, 0.0381);
-#407 = CARTESIAN_POINT('NONE', (0, 0.01905, -0));
-#408 = DIRECTION('NONE', (0, 1, 0));
-#409 = AXIS2_PLACEMENT_3D('NONE', #407, #408, $);
-#410 = PLANE('NONE', #409);
-#411 = CARTESIAN_POINT('NONE', (0, 0.0254, -0));
-#412 = DIRECTION('NONE', (0, 1, 0));
-#413 = AXIS2_PLACEMENT_3D('NONE', #411, #412, $);
-#414 = PLANE('NONE', #413);
-#415 = CARTESIAN_POINT('NONE', (0, 0.009524999999999999, 0.07619999999999999));
-#416 = DIRECTION('NONE', (0, 0, 1));
-#417 = AXIS2_PLACEMENT_3D('NONE', #415, #416, $);
-#418 = PLANE('NONE', #417);
-#419 = CARTESIAN_POINT('NONE', (0.0508, 0.009525, -0.000000000000000014210854715202004));
-#420 = DIRECTION('NONE', (1, 0, 0));
-#421 = AXIS2_PLACEMENT_3D('NONE', #419, #420, $);
-#422 = PLANE('NONE', #421);
-#423 = CARTESIAN_POINT('NONE', (0, 0.009525, -0.0762));
-#424 = DIRECTION('NONE', (0, -0, -1));
-#425 = AXIS2_PLACEMENT_3D('NONE', #423, #424, $);
-#426 = PLANE('NONE', #425);
-#427 = CARTESIAN_POINT('NONE', (-0.0508, 0.009525, -0));
-#428 = DIRECTION('NONE', (-1, 0, 0));
-#429 = AXIS2_PLACEMENT_3D('NONE', #427, #428, $);
-#430 = PLANE('NONE', #429);
-#431 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.009525, 0.057150000000000006));
-#432 = DIRECTION('NONE', (0, -1, 0));
-#433 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#434 = AXIS2_PLACEMENT_3D('NONE', #431, #432, #433);
-#435 = CYLINDRICAL_SURFACE('NONE', #434, 0.004762499999999996);
-#436 = CARTESIAN_POINT('NONE', (-0.031749999999999994, 0.009525, -0.05714999999999999));
-#437 = DIRECTION('NONE', (0, -1, 0));
-#438 = DIRECTION('NONE', (1, 0, -0.0000000000000014919532509398443));
-#439 = AXIS2_PLACEMENT_3D('NONE', #436, #437, #438);
-#440 = CYLINDRICAL_SURFACE('NONE', #439, 0.004762499999999996);
-#441 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.009525, -0.05714999999999999));
-#442 = DIRECTION('NONE', (0, -1, 0));
-#443 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#444 = AXIS2_PLACEMENT_3D('NONE', #441, #442, #443);
-#445 = CYLINDRICAL_SURFACE('NONE', #444, 0.004762500000000006);
-#446 = CARTESIAN_POINT('NONE', (0.031749999999999994, 0.009525, 0.057150000000000006));
-#447 = DIRECTION('NONE', (0, -1, 0));
-#448 = DIRECTION('NONE', (1, 0, -0.000000000000001491953250939841));
-#449 = AXIS2_PLACEMENT_3D('NONE', #446, #447, #448);
-#450 = CYLINDRICAL_SURFACE('NONE', #449, 0.004762500000000006);
-#451 = CARTESIAN_POINT('NONE', (-0.0000000000000000025121479338940404, 0.009525, -0.000000000000000000000000000000000418356671621052));
-#452 = DIRECTION('NONE', (0, -1, 0));
-#453 = DIRECTION('NONE', (1, 0, 0.00000000000000024492935982947064));
-#454 = AXIS2_PLACEMENT_3D('NONE', #451, #452, #453);
-#455 = CYLINDRICAL_SURFACE('NONE', #454, 0.0381);
-#456 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#457 = DIRECTION('NONE', (0, 1, 0));
-#458 = AXIS2_PLACEMENT_3D('NONE', #456, #457, $);
-#459 = PLANE('NONE', #458);
-#460 = CARTESIAN_POINT('NONE', (0, 0.01905, -0));
-#461 = DIRECTION('NONE', (0, 1, 0));
-#462 = AXIS2_PLACEMENT_3D('NONE', #460, #461, $);
-#463 = PLANE('NONE', #462);
-#464 = ORIENTED_EDGE('NONE', *, *, #312, .T.);
-#465 = ORIENTED_EDGE('NONE', *, *, #313, .T.);
-#466 = ORIENTED_EDGE('NONE', *, *, #314, .F.);
-#467 = ORIENTED_EDGE('NONE', *, *, #315, .F.);
-#468 = EDGE_LOOP('NONE', (#464, #465, #466, #467));
-#469 = FACE_BOUND('NONE', #468, .T.);
-#470 = ADVANCED_FACE('NONE', (#469), #369, .T.);
-#471 = ORIENTED_EDGE('NONE', *, *, #316, .T.);
-#472 = ORIENTED_EDGE('NONE', *, *, #317, .T.);
-#473 = ORIENTED_EDGE('NONE', *, *, #318, .F.);
-#474 = ORIENTED_EDGE('NONE', *, *, #313, .F.);
-#475 = EDGE_LOOP('NONE', (#471, #472, #473, #474));
-#476 = FACE_BOUND('NONE', #475, .T.);
-#477 = ADVANCED_FACE('NONE', (#476), #373, .T.);
-#478 = ORIENTED_EDGE('NONE', *, *, #319, .T.);
-#479 = ORIENTED_EDGE('NONE', *, *, #320, .T.);
-#480 = ORIENTED_EDGE('NONE', *, *, #321, .F.);
-#481 = ORIENTED_EDGE('NONE', *, *, #317, .F.);
-#482 = EDGE_LOOP('NONE', (#478, #479, #480, #481));
-#483 = FACE_BOUND('NONE', #482, .T.);
-#484 = ADVANCED_FACE('NONE', (#483), #377, .T.);
-#485 = ORIENTED_EDGE('NONE', *, *, #322, .T.);
-#486 = ORIENTED_EDGE('NONE', *, *, #315, .T.);
-#487 = ORIENTED_EDGE('NONE', *, *, #323, .F.);
-#488 = ORIENTED_EDGE('NONE', *, *, #320, .F.);
-#489 = EDGE_LOOP('NONE', (#485, #486, #487, #488));
-#490 = FACE_BOUND('NONE', #489, .T.);
-#491 = ADVANCED_FACE('NONE', (#490), #381, .T.);
-#492 = ORIENTED_EDGE('NONE', *, *, #324, .T.);
-#493 = ORIENTED_EDGE('NONE', *, *, #326, .F.);
-#494 = EDGE_LOOP('NONE', (#492));
-#495 = FACE_BOUND('NONE', #494, .T.);
-#496 = EDGE_LOOP('NONE', (#493));
-#497 = FACE_BOUND('NONE', #496, .T.);
-#498 = ADVANCED_FACE('NONE', (#495, #497), #386, .F.);
-#499 = ORIENTED_EDGE('NONE', *, *, #327, .T.);
-#500 = ORIENTED_EDGE('NONE', *, *, #329, .F.);
-#501 = EDGE_LOOP('NONE', (#499));
-#502 = FACE_BOUND('NONE', #501, .T.);
-#503 = EDGE_LOOP('NONE', (#500));
-#504 = FACE_BOUND('NONE', #503, .T.);
-#505 = ADVANCED_FACE('NONE', (#502, #504), #391, .F.);
-#506 = ORIENTED_EDGE('NONE', *, *, #330, .T.);
-#507 = ORIENTED_EDGE('NONE', *, *, #332, .F.);
-#508 = EDGE_LOOP('NONE', (#506));
-#509 = FACE_BOUND('NONE', #508, .T.);
-#510 = EDGE_LOOP('NONE', (#507));
-#511 = FACE_BOUND('NONE', #510, .T.);
-#512 = ADVANCED_FACE('NONE', (#509, #511), #396, .F.);
-#513 = ORIENTED_EDGE('NONE', *, *, #333, .T.);
-#514 = ORIENTED_EDGE('NONE', *, *, #335, .F.);
-#515 = EDGE_LOOP('NONE', (#513));
-#516 = FACE_BOUND('NONE', #515, .T.);
-#517 = EDGE_LOOP('NONE', (#514));
-#518 = FACE_BOUND('NONE', #517, .T.);
-#519 = ADVANCED_FACE('NONE', (#516, #518), #401, .F.);
-#520 = ORIENTED_EDGE('NONE', *, *, #336, .T.);
-#521 = ORIENTED_EDGE('NONE', *, *, #338, .F.);
-#522 = EDGE_LOOP('NONE', (#520));
-#523 = FACE_BOUND('NONE', #522, .T.);
-#524 = EDGE_LOOP('NONE', (#521));
-#525 = FACE_BOUND('NONE', #524, .T.);
-#526 = ADVANCED_FACE('NONE', (#523, #525), #406, .F.);
-#527 = ORIENTED_EDGE('NONE', *, *, #322, .F.);
-#528 = ORIENTED_EDGE('NONE', *, *, #319, .F.);
-#529 = ORIENTED_EDGE('NONE', *, *, #316, .F.);
-#530 = ORIENTED_EDGE('NONE', *, *, #312, .F.);
-#531 = ORIENTED_EDGE('NONE', *, *, #324, .F.);
-#532 = ORIENTED_EDGE('NONE', *, *, #327, .F.);
-#533 = ORIENTED_EDGE('NONE', *, *, #330, .F.);
-#534 = ORIENTED_EDGE('NONE', *, *, #333, .F.);
-#535 = ORIENTED_EDGE('NONE', *, *, #336, .F.);
-#536 = EDGE_LOOP('NONE', (#527, #528, #529, #530));
-#537 = FACE_BOUND('NONE', #536, .T.);
-#538 = EDGE_LOOP('NONE', (#531));
-#539 = FACE_BOUND('NONE', #538, .T.);
-#540 = EDGE_LOOP('NONE', (#532));
-#541 = FACE_BOUND('NONE', #540, .T.);
-#542 = EDGE_LOOP('NONE', (#533));
-#543 = FACE_BOUND('NONE', #542, .T.);
-#544 = EDGE_LOOP('NONE', (#534));
-#545 = FACE_BOUND('NONE', #544, .T.);
-#546 = EDGE_LOOP('NONE', (#535));
-#547 = FACE_BOUND('NONE', #546, .T.);
-#548 = ADVANCED_FACE('NONE', (#537, #539, #541, #543, #545, #547), #410, .F.);
-#549 = ORIENTED_EDGE('NONE', *, *, #314, .T.);
-#550 = ORIENTED_EDGE('NONE', *, *, #318, .T.);
-#551 = ORIENTED_EDGE('NONE', *, *, #321, .T.);
-#552 = ORIENTED_EDGE('NONE', *, *, #323, .T.);
-#553 = ORIENTED_EDGE('NONE', *, *, #326, .T.);
-#554 = ORIENTED_EDGE('NONE', *, *, #329, .T.);
-#555 = ORIENTED_EDGE('NONE', *, *, #332, .T.);
-#556 = ORIENTED_EDGE('NONE', *, *, #335, .T.);
-#557 = ORIENTED_EDGE('NONE', *, *, #338, .T.);
-#558 = EDGE_LOOP('NONE', (#549, #550, #551, #552));
-#559 = FACE_BOUND('NONE', #558, .T.);
-#560 = EDGE_LOOP('NONE', (#553));
-#561 = FACE_BOUND('NONE', #560, .T.);
-#562 = EDGE_LOOP('NONE', (#554));
-#563 = FACE_BOUND('NONE', #562, .T.);
-#564 = EDGE_LOOP('NONE', (#555));
-#565 = FACE_BOUND('NONE', #564, .T.);
-#566 = EDGE_LOOP('NONE', (#556));
-#567 = FACE_BOUND('NONE', #566, .T.);
-#568 = EDGE_LOOP('NONE', (#557));
-#569 = FACE_BOUND('NONE', #568, .T.);
-#570 = ADVANCED_FACE('NONE', (#559, #561, #563, #565, #567, #569), #414, .T.);
-#571 = ORIENTED_EDGE('NONE', *, *, #339, .T.);
-#572 = ORIENTED_EDGE('NONE', *, *, #340, .T.);
-#573 = ORIENTED_EDGE('NONE', *, *, #341, .F.);
-#574 = ORIENTED_EDGE('NONE', *, *, #342, .F.);
-#575 = EDGE_LOOP('NONE', (#571, #572, #573, #574));
-#576 = FACE_BOUND('NONE', #575, .T.);
-#577 = ADVANCED_FACE('NONE', (#576), #418, .T.);
-#578 = ORIENTED_EDGE('NONE', *, *, #343, .T.);
-#579 = ORIENTED_EDGE('NONE', *, *, #344, .T.);
-#580 = ORIENTED_EDGE('NONE', *, *, #345, .F.);
-#581 = ORIENTED_EDGE('NONE', *, *, #340, .F.);
-#582 = EDGE_LOOP('NONE', (#578, #579, #580, #581));
-#583 = FACE_BOUND('NONE', #582, .T.);
-#584 = ADVANCED_FACE('NONE', (#583), #422, .T.);
-#585 = ORIENTED_EDGE('NONE', *, *, #346, .T.);
-#586 = ORIENTED_EDGE('NONE', *, *, #347, .T.);
-#587 = ORIENTED_EDGE('NONE', *, *, #348, .F.);
-#588 = ORIENTED_EDGE('NONE', *, *, #344, .F.);
-#589 = EDGE_LOOP('NONE', (#585, #586, #587, #588));
-#590 = FACE_BOUND('NONE', #589, .T.);
-#591 = ADVANCED_FACE('NONE', (#590), #426, .T.);
-#592 = ORIENTED_EDGE('NONE', *, *, #349, .T.);
-#593 = ORIENTED_EDGE('NONE', *, *, #342, .T.);
-#594 = ORIENTED_EDGE('NONE', *, *, #350, .F.);
-#595 = ORIENTED_EDGE('NONE', *, *, #347, .F.);
-#596 = EDGE_LOOP('NONE', (#592, #593, #594, #595));
-#597 = FACE_BOUND('NONE', #596, .T.);
-#598 = ADVANCED_FACE('NONE', (#597), #430, .T.);
-#599 = ORIENTED_EDGE('NONE', *, *, #351, .T.);
-#600 = ORIENTED_EDGE('NONE', *, *, #353, .F.);
-#601 = EDGE_LOOP('NONE', (#599));
-#602 = FACE_BOUND('NONE', #601, .T.);
-#603 = EDGE_LOOP('NONE', (#600));
-#604 = FACE_BOUND('NONE', #603, .T.);
-#605 = ADVANCED_FACE('NONE', (#602, #604), #435, .F.);
-#606 = ORIENTED_EDGE('NONE', *, *, #354, .T.);
-#607 = ORIENTED_EDGE('NONE', *, *, #356, .F.);
-#608 = EDGE_LOOP('NONE', (#606));
-#609 = FACE_BOUND('NONE', #608, .T.);
-#610 = EDGE_LOOP('NONE', (#607));
-#611 = FACE_BOUND('NONE', #610, .T.);
-#612 = ADVANCED_FACE('NONE', (#609, #611), #440, .F.);
-#613 = ORIENTED_EDGE('NONE', *, *, #357, .T.);
-#614 = ORIENTED_EDGE('NONE', *, *, #359, .F.);
-#615 = EDGE_LOOP('NONE', (#613));
-#616 = FACE_BOUND('NONE', #615, .T.);
-#617 = EDGE_LOOP('NONE', (#614));
-#618 = FACE_BOUND('NONE', #617, .T.);
-#619 = ADVANCED_FACE('NONE', (#616, #618), #445, .F.);
-#620 = ORIENTED_EDGE('NONE', *, *, #360, .T.);
-#621 = ORIENTED_EDGE('NONE', *, *, #362, .F.);
-#622 = EDGE_LOOP('NONE', (#620));
-#623 = FACE_BOUND('NONE', #622, .T.);
-#624 = EDGE_LOOP('NONE', (#621));
-#625 = FACE_BOUND('NONE', #624, .T.);
-#626 = ADVANCED_FACE('NONE', (#623, #625), #450, .F.);
-#627 = ORIENTED_EDGE('NONE', *, *, #363, .T.);
-#628 = ORIENTED_EDGE('NONE', *, *, #365, .F.);
-#629 = EDGE_LOOP('NONE', (#627));
-#630 = FACE_BOUND('NONE', #629, .T.);
-#631 = EDGE_LOOP('NONE', (#628));
-#632 = FACE_BOUND('NONE', #631, .T.);
-#633 = ADVANCED_FACE('NONE', (#630, #632), #455, .F.);
-#634 = ORIENTED_EDGE('NONE', *, *, #349, .F.);
-#635 = ORIENTED_EDGE('NONE', *, *, #346, .F.);
-#636 = ORIENTED_EDGE('NONE', *, *, #343, .F.);
-#637 = ORIENTED_EDGE('NONE', *, *, #339, .F.);
-#638 = ORIENTED_EDGE('NONE', *, *, #351, .F.);
-#639 = ORIENTED_EDGE('NONE', *, *, #354, .F.);
-#640 = ORIENTED_EDGE('NONE', *, *, #357, .F.);
-#641 = ORIENTED_EDGE('NONE', *, *, #360, .F.);
-#642 = ORIENTED_EDGE('NONE', *, *, #363, .F.);
-#643 = EDGE_LOOP('NONE', (#634, #635, #636, #637));
-#644 = FACE_BOUND('NONE', #643, .T.);
-#645 = EDGE_LOOP('NONE', (#638));
-#646 = FACE_BOUND('NONE', #645, .T.);
-#647 = EDGE_LOOP('NONE', (#639));
-#648 = FACE_BOUND('NONE', #647, .T.);
-#649 = EDGE_LOOP('NONE', (#640));
-#650 = FACE_BOUND('NONE', #649, .T.);
-#651 = EDGE_LOOP('NONE', (#641));
-#652 = FACE_BOUND('NONE', #651, .T.);
-#653 = EDGE_LOOP('NONE', (#642));
-#654 = FACE_BOUND('NONE', #653, .T.);
-#655 = ADVANCED_FACE('NONE', (#644, #646, #648, #650, #652, #654), #459, .F.);
-#656 = ORIENTED_EDGE('NONE', *, *, #341, .T.);
-#657 = ORIENTED_EDGE('NONE', *, *, #345, .T.);
-#658 = ORIENTED_EDGE('NONE', *, *, #348, .T.);
-#659 = ORIENTED_EDGE('NONE', *, *, #350, .T.);
-#660 = ORIENTED_EDGE('NONE', *, *, #353, .T.);
-#661 = ORIENTED_EDGE('NONE', *, *, #356, .T.);
-#662 = ORIENTED_EDGE('NONE', *, *, #359, .T.);
-#663 = ORIENTED_EDGE('NONE', *, *, #362, .T.);
-#664 = ORIENTED_EDGE('NONE', *, *, #365, .T.);
-#665 = EDGE_LOOP('NONE', (#656, #657, #658, #659));
-#666 = FACE_BOUND('NONE', #665, .T.);
-#667 = EDGE_LOOP('NONE', (#660));
-#668 = FACE_BOUND('NONE', #667, .T.);
-#669 = EDGE_LOOP('NONE', (#661));
-#670 = FACE_BOUND('NONE', #669, .T.);
-#671 = EDGE_LOOP('NONE', (#662));
-#672 = FACE_BOUND('NONE', #671, .T.);
-#673 = EDGE_LOOP('NONE', (#663));
-#674 = FACE_BOUND('NONE', #673, .T.);
-#675 = EDGE_LOOP('NONE', (#664));
-#676 = FACE_BOUND('NONE', #675, .T.);
-#677 = ADVANCED_FACE('NONE', (#666, #668, #670, #672, #674, #676), #463, .T.);
-#678 = CLOSED_SHELL('NONE', (#470, #477, #484, #491, #498, #505, #512, #519, #526, #548, #570));
-#679 = CLOSED_SHELL('NONE', (#577, #584, #591, #598, #605, #612, #619, #626, #633, #655, #677));
-#680 = MANIFOLD_SOLID_BREP('NONE', #678);
-#681 = MANIFOLD_SOLID_BREP('NONE', #679);
-#682 = APPLICATION_CONTEXT('configuration controlled 3D design of mechanical parts and assemblies');
-#683 = PRODUCT_DEFINITION_CONTEXT('part definition', #682, 'design');
-#684 = PRODUCT('UNIDENTIFIED_PRODUCT', 'NONE', $, ());
-#685 = PRODUCT_DEFINITION_FORMATION('', $, #684);
-#686 = PRODUCT_DEFINITION('design', $, #685, #683);
-#687 = PRODUCT_DEFINITION_SHAPE('NONE', $, #686);
-#688 = ADVANCED_BREP_SHAPE_REPRESENTATION('NONE', (#681), #3);
-#689 = SHAPE_DEFINITION_REPRESENTATION(#687, #688);
-#690 = PRODUCT('UNIDENTIFIED_PRODUCT', 'NONE', $, ());
-#691 = PRODUCT_DEFINITION_FORMATION('', $, #690);
-#692 = PRODUCT_DEFINITION('design', $, #691, #683);
-#693 = PRODUCT_DEFINITION_SHAPE('NONE', $, #692);
-#694 = ADVANCED_BREP_SHAPE_REPRESENTATION('NONE', (#680), #3);
-#695 = SHAPE_DEFINITION_REPRESENTATION(#693, #694);
-ENDSEC;
-END-ISO-10303-21;

rust/kcl-lib/tests/kcl_samples/bracket/exported_step.macos.step

@@ -1,853 +0,0 @@
-ISO-10303-21;
-HEADER;
-FILE_DESCRIPTION((('zoo.dev export')), '2;1');
-FILE_NAME('test.step', '2021-01-01T00:00:00Z', ('Test'), ('Zoo'), 'zoo.dev beta', 'zoo.dev', 'Test');
-FILE_SCHEMA(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF'));
-ENDSEC;
-DATA;
-#1 = (
-  LENGTH_UNIT()
-  NAMED_UNIT(*)
-  SI_UNIT($, .METRE.)
-);
-#2 = UNCERTAINTY_MEASURE_WITH_UNIT(0.00001, #1, 'DISTANCE_ACCURACY_VALUE', $);
-#3 = (
-  GEOMETRIC_REPRESENTATION_CONTEXT(3)
-  GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#2))
-  GLOBAL_UNIT_ASSIGNED_CONTEXT((#1))
-  REPRESENTATION_CONTEXT('', '3D')
-);
-#4 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0));
-#5 = VERTEX_POINT('NONE', #4);
-#6 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0));
-#7 = VERTEX_POINT('NONE', #6);
-#8 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0.1524));
-#9 = VERTEX_POINT('NONE', #8);
-#10 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0.1524));
-#11 = VERTEX_POINT('NONE', #10);
-#12 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.0381, -0.03175));
-#13 = VERTEX_POINT('NONE', #12);
-#14 = CARTESIAN_POINT('NONE', (-0.009525, -0.0381, -0.03175));
-#15 = VERTEX_POINT('NONE', #14);
-#16 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.0381, -0.13335));
-#17 = VERTEX_POINT('NONE', #16);
-#18 = CARTESIAN_POINT('NONE', (-0.009525, -0.0381, -0.13335));
-#19 = VERTEX_POINT('NONE', #18);
-#20 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.060325, -0.14605));
-#21 = VERTEX_POINT('NONE', #20);
-#22 = CARTESIAN_POINT('NONE', (-0.009525, -0.060325, -0.14605));
-#23 = VERTEX_POINT('NONE', #22);
-#24 = CARTESIAN_POINT('NONE', (-0.009525, -0.053974999999999995, -0.15240000000000004));
-#25 = VERTEX_POINT('NONE', #24);
-#26 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.053974999999999995, -0.15240000000000004));
-#27 = VERTEX_POINT('NONE', #26);
-#28 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.053974999999999995, -0));
-#29 = VERTEX_POINT('NONE', #28);
-#30 = CARTESIAN_POINT('NONE', (-0.009525, -0.053974999999999995, -0));
-#31 = VERTEX_POINT('NONE', #30);
-#32 = CARTESIAN_POINT('NONE', (-0.009525, -0.060325, -0.00635));
-#33 = VERTEX_POINT('NONE', #32);
-#34 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.060325, -0.00635));
-#35 = VERTEX_POINT('NONE', #34);
-#36 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#37 = VERTEX_POINT('NONE', #36);
-#38 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0.1524));
-#39 = VERTEX_POINT('NONE', #38);
-#40 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0));
-#41 = VERTEX_POINT('NONE', #40);
-#42 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#43 = VERTEX_POINT('NONE', #42);
-#44 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009524999999999999, -0.1524));
-#45 = VERTEX_POINT('NONE', #44);
-#46 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009524999999999999, -0));
-#47 = VERTEX_POINT('NONE', #46);
-#48 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0.1524));
-#49 = VERTEX_POINT('NONE', #48);
-#50 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0));
-#51 = VERTEX_POINT('NONE', #50);
-#52 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#53 = VERTEX_POINT('NONE', #52);
-#54 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0));
-#55 = VERTEX_POINT('NONE', #54);
-#56 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#57 = VERTEX_POINT('NONE', #56);
-#58 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0.1524));
-#59 = VERTEX_POINT('NONE', #58);
-#60 = CARTESIAN_POINT('NONE', (0.03175, 0, -0.0254));
-#61 = VERTEX_POINT('NONE', #60);
-#62 = CARTESIAN_POINT('NONE', (0.03175, 0.008923630267041387, -0.0254));
-#63 = VERTEX_POINT('NONE', #62);
-#64 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0, -0.127));
-#65 = VERTEX_POINT('NONE', #64);
-#66 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0.008923630267041387, -0.127));
-#67 = VERTEX_POINT('NONE', #66);
-#68 = CARTESIAN_POINT('NONE', (0.03175, 0, -0.127));
-#69 = VERTEX_POINT('NONE', #68);
-#70 = CARTESIAN_POINT('NONE', (0.03175, 0.008923630267041387, -0.127));
-#71 = VERTEX_POINT('NONE', #70);
-#72 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0, -0.0254));
-#73 = VERTEX_POINT('NONE', #72);
-#74 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0.008923630267041387, -0.0254));
-#75 = VERTEX_POINT('NONE', #74);
-#76 = CARTESIAN_POINT('NONE', (0.111125, 0, -0));
-#77 = VERTEX_POINT('NONE', #76);
-#78 = CARTESIAN_POINT('NONE', (0.111125, 0.008923630267041387, -0));
-#79 = VERTEX_POINT('NONE', #78);
-#80 = CARTESIAN_POINT('NONE', (0.117475, 0.008923630267041387, -0.00635));
-#81 = VERTEX_POINT('NONE', #80);
-#82 = CARTESIAN_POINT('NONE', (0.117475, 0, -0.00635));
-#83 = VERTEX_POINT('NONE', #82);
-#84 = CARTESIAN_POINT('NONE', (0.117475, 0, -0.14605));
-#85 = VERTEX_POINT('NONE', #84);
-#86 = CARTESIAN_POINT('NONE', (0.117475, 0.008923630267041387, -0.14605));
-#87 = VERTEX_POINT('NONE', #86);
-#88 = CARTESIAN_POINT('NONE', (0.111125, 0.008923630267041387, -0.1524));
-#89 = VERTEX_POINT('NONE', #88);
-#90 = CARTESIAN_POINT('NONE', (0.111125, 0, -0.1524));
-#91 = VERTEX_POINT('NONE', #90);
-#92 = DIRECTION('NONE', (1, 0, 0));
-#93 = VECTOR('NONE', #92, 1);
-#94 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0));
-#95 = LINE('NONE', #94, #93);
-#96 = DIRECTION('NONE', (1, 0, 0));
-#97 = VECTOR('NONE', #96, 1);
-#98 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0.1524));
-#99 = LINE('NONE', #98, #97);
-#100 = DIRECTION('NONE', (0, 0, 1));
-#101 = VECTOR('NONE', #100, 1);
-#102 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0.1524));
-#103 = LINE('NONE', #102, #101);
-#104 = DIRECTION('NONE', (0, 0, 1));
-#105 = VECTOR('NONE', #104, 1);
-#106 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0.1524));
-#107 = LINE('NONE', #106, #105);
-#108 = DIRECTION('NONE', (0, 0.0000000000000011189649382048832, -1));
-#109 = DIRECTION('NONE', (-1, 0, -0));
-#110 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.03810000000000001, -0.025400000000000006));
-#111 = AXIS2_PLACEMENT_3D('NONE', #110, #109, #108);
-#112 = CIRCLE('NONE', #111, 0.0063499999999999945);
-#113 = DIRECTION('NONE', (1, 0, 0));
-#114 = VECTOR('NONE', #113, 1);
-#115 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.0381, -0.03175));
-#116 = LINE('NONE', #115, #114);
-#117 = DIRECTION('NONE', (0, 0.0000000000000011189649382048832, -1));
-#118 = DIRECTION('NONE', (-1, 0, -0));
-#119 = CARTESIAN_POINT('NONE', (-0.009525, -0.03810000000000001, -0.025400000000000006));
-#120 = AXIS2_PLACEMENT_3D('NONE', #119, #118, #117);
-#121 = CIRCLE('NONE', #120, 0.0063499999999999945);
-#122 = DIRECTION('NONE', (0, 0.0000000000000011189649382048857, -1));
-#123 = DIRECTION('NONE', (-1, 0, -0));
-#124 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.03810000000000001, -0.127));
-#125 = AXIS2_PLACEMENT_3D('NONE', #124, #123, #122);
-#126 = CIRCLE('NONE', #125, 0.00634999999999998);
-#127 = DIRECTION('NONE', (1, 0, 0));
-#128 = VECTOR('NONE', #127, 1);
-#129 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.0381, -0.13335));
-#130 = LINE('NONE', #129, #128);
-#131 = DIRECTION('NONE', (0, 0.0000000000000011189649382048857, -1));
-#132 = DIRECTION('NONE', (-1, 0, -0));
-#133 = CARTESIAN_POINT('NONE', (-0.009525, -0.03810000000000001, -0.127));
-#134 = AXIS2_PLACEMENT_3D('NONE', #133, #132, #131);
-#135 = CIRCLE('NONE', #134, 0.00634999999999998);
-#136 = DIRECTION('NONE', (1, 0, 0));
-#137 = VECTOR('NONE', #136, 1);
-#138 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.060325, -0.14605));
-#139 = LINE('NONE', #138, #137);
-#140 = DIRECTION('NONE', (0, -1, 0.000000000000004475859752819533));
-#141 = DIRECTION('NONE', (1, 0, 0));
-#142 = CARTESIAN_POINT('NONE', (-0.009525, -0.053975, -0.14605000000000004));
-#143 = AXIS2_PLACEMENT_3D('NONE', #142, #141, #140);
-#144 = CIRCLE('NONE', #143, 0.0063499999999999945);
-#145 = DIRECTION('NONE', (-1, 0, 0));
-#146 = VECTOR('NONE', #145, 1);
-#147 = CARTESIAN_POINT('NONE', (-0.009525, -0.053974999999999995, -0.15240000000000004));
-#148 = LINE('NONE', #147, #146);
-#149 = DIRECTION('NONE', (-0.0000000000000016784474073073173, 0, -1));
-#150 = DIRECTION('NONE', (-1, 0.0000000000000013507101648170894, 0.0000000000000016784474073073173));
-#151 = CARTESIAN_POINT('NONE', (-0.018448630267041376, -0.053974999999999995, -0.14605));
-#152 = AXIS2_PLACEMENT_3D('NONE', #151, #150, #149);
-#153 = CIRCLE('NONE', #152, 0.006350000000000023);
-#154 = DIRECTION('NONE', (0, 1, 0));
-#155 = VECTOR('NONE', #154, 1);
-#156 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.05397500000000006, -0.1524));
-#157 = LINE('NONE', #156, #155);
-#158 = DIRECTION('NONE', (0, -1, 0));
-#159 = VECTOR('NONE', #158, 1);
-#160 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0.1524));
-#161 = LINE('NONE', #160, #159);
-#162 = DIRECTION('NONE', (1, 0, 0));
-#163 = VECTOR('NONE', #162, 1);
-#164 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.053974999999999995, -0));
-#165 = LINE('NONE', #164, #163);
-#166 = DIRECTION('NONE', (0, 0.000000000000002237929876409769, 1));
-#167 = DIRECTION('NONE', (1, 0, -0));
-#168 = CARTESIAN_POINT('NONE', (-0.009525, -0.05397500000000001, -0.006349999999999988));
-#169 = AXIS2_PLACEMENT_3D('NONE', #168, #167, #166);
-#170 = CIRCLE('NONE', #169, 0.006349999999999988);
-#171 = DIRECTION('NONE', (-1, 0, 0));
-#172 = VECTOR('NONE', #171, 1);
-#173 = CARTESIAN_POINT('NONE', (-0.009525, -0.060325, -0.00635));
-#174 = LINE('NONE', #173, #172);
-#175 = DIRECTION('NONE', (-0.0000000000000016784474073073266, -1, -0.000000000000001958188641858548));
-#176 = DIRECTION('NONE', (-1, 0.0000000000000016784474073073292, -0.0000000000000013507101648170935));
-#177 = CARTESIAN_POINT('NONE', (-0.018448630267041376, -0.05397500000000001, -0.006349999999999988));
-#178 = AXIS2_PLACEMENT_3D('NONE', #177, #176, #175);
-#179 = CIRCLE('NONE', #178, 0.006349999999999988);
-#180 = DIRECTION('NONE', (0, -1, 0));
-#181 = VECTOR('NONE', #180, 1);
-#182 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0));
-#183 = LINE('NONE', #182, #181);
-#184 = DIRECTION('NONE', (0, 1, 0));
-#185 = VECTOR('NONE', #184, 1);
-#186 = CARTESIAN_POINT('NONE', (-0.009525, -0.05397500000000014, -0));
-#187 = LINE('NONE', #186, #185);
-#188 = DIRECTION('NONE', (-0.000000000000000024834981760584213, 0, -1));
-#189 = VECTOR('NONE', #188, 1);
-#190 = CARTESIAN_POINT('NONE', (-0.018448630267041383, -0.060325, -0.0063500000000000206));
-#191 = LINE('NONE', #190, #189);
-#192 = DIRECTION('NONE', (0, 0, 1));
-#193 = VECTOR('NONE', #192, 1);
-#194 = CARTESIAN_POINT('NONE', (-0.009525, -0.060325, -0.14604999999999999));
-#195 = LINE('NONE', #194, #193);
-#196 = DIRECTION('NONE', (0, 1, 0));
-#197 = VECTOR('NONE', #196, 1);
-#198 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#199 = LINE('NONE', #198, #197);
-#200 = DIRECTION('NONE', (0, 0, 1));
-#201 = VECTOR('NONE', #200, 1);
-#202 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0.1524));
-#203 = LINE('NONE', #202, #201);
-#204 = DIRECTION('NONE', (0, 1, 0));
-#205 = VECTOR('NONE', #204, 1);
-#206 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#207 = LINE('NONE', #206, #205);
-#208 = DIRECTION('NONE', (0, 0, 1));
-#209 = VECTOR('NONE', #208, 1);
-#210 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#211 = LINE('NONE', #210, #209);
-#212 = DIRECTION('NONE', (0.00000000000000021664496663423743, 1, -0));
-#213 = DIRECTION('NONE', (0, 0, 1));
-#214 = CARTESIAN_POINT('NONE', (-0.000000000000000003996802888650563, -0.009524999999999997, -0.1524));
-#215 = AXIS2_PLACEMENT_3D('NONE', #214, #213, #212);
-#216 = CIRCLE('NONE', #215, 0.018448630267041383);
-#217 = DIRECTION('NONE', (0, 0, 1));
-#218 = VECTOR('NONE', #217, 1);
-#219 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009524999999999999, -0.1524));
-#220 = LINE('NONE', #219, #218);
-#221 = DIRECTION('NONE', (0.00000000000000021664496663423743, 1, -0));
-#222 = DIRECTION('NONE', (0, 0, 1));
-#223 = CARTESIAN_POINT('NONE', (-0.000000000000000003996802888650563, -0.009524999999999997, 0));
-#224 = AXIS2_PLACEMENT_3D('NONE', #223, #222, #221);
-#225 = CIRCLE('NONE', #224, 0.018448630267041383);
-#226 = DIRECTION('NONE', (1, 0, 0));
-#227 = VECTOR('NONE', #226, 1);
-#228 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0.1524));
-#229 = LINE('NONE', #228, #227);
-#230 = DIRECTION('NONE', (0, 0, 1));
-#231 = VECTOR('NONE', #230, 1);
-#232 = CARTESIAN_POINT('NONE', (-0.009525, -0.009525, -0.1524));
-#233 = LINE('NONE', #232, #231);
-#234 = DIRECTION('NONE', (1, 0, 0));
-#235 = VECTOR('NONE', #234, 1);
-#236 = CARTESIAN_POINT('NONE', (-0.018448630267041386, -0.009525, -0));
-#237 = LINE('NONE', #236, #235);
-#238 = DIRECTION('NONE', (-1, 0.00000000000000018649415636748036, -0));
-#239 = DIRECTION('NONE', (0, -0, -1));
-#240 = CARTESIAN_POINT('NONE', (-0.0000000000000000004440892098500626, -0.009524999999999999, -0.1524));
-#241 = AXIS2_PLACEMENT_3D('NONE', #240, #239, #238);
-#242 = CIRCLE('NONE', #241, 0.009525);
-#243 = DIRECTION('NONE', (-1, 0.00000000000000018649415636748036, -0));
-#244 = DIRECTION('NONE', (0, -0, -1));
-#245 = CARTESIAN_POINT('NONE', (-0.0000000000000000004440892098500626, -0.009524999999999999, -0));
-#246 = AXIS2_PLACEMENT_3D('NONE', #245, #244, #243);
-#247 = CIRCLE('NONE', #246, 0.009525);
-#248 = DIRECTION('NONE', (0, 1, 0));
-#249 = VECTOR('NONE', #248, 1);
-#250 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#251 = LINE('NONE', #250, #249);
-#252 = DIRECTION('NONE', (0, 1, 0));
-#253 = VECTOR('NONE', #252, 1);
-#254 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#255 = LINE('NONE', #254, #253);
-#256 = DIRECTION('NONE', (0, 0, 1));
-#257 = VECTOR('NONE', #256, 1);
-#258 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#259 = LINE('NONE', #258, #257);
-#260 = DIRECTION('NONE', (0, 0, 1));
-#261 = VECTOR('NONE', #260, 1);
-#262 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0.1524));
-#263 = LINE('NONE', #262, #261);
-#264 = DIRECTION('NONE', (1, 0, -0));
-#265 = DIRECTION('NONE', (0, -1, 0));
-#266 = CARTESIAN_POINT('NONE', (0.0254, -0, -0.0254));
-#267 = AXIS2_PLACEMENT_3D('NONE', #266, #265, #264);
-#268 = CIRCLE('NONE', #267, 0.0063500000000000015);
-#269 = DIRECTION('NONE', (0, 1, 0));
-#270 = VECTOR('NONE', #269, 1);
-#271 = CARTESIAN_POINT('NONE', (0.03175, 0, -0.0254));
-#272 = LINE('NONE', #271, #270);
-#273 = DIRECTION('NONE', (1, 0, -0));
-#274 = DIRECTION('NONE', (0, -1, 0));
-#275 = CARTESIAN_POINT('NONE', (0.0254, 0.008923630267041387, -0.0254));
-#276 = AXIS2_PLACEMENT_3D('NONE', #275, #274, #273);
-#277 = CIRCLE('NONE', #276, 0.0063500000000000015);
-#278 = DIRECTION('NONE', (1, 0, 0.0000000000000022379298764097663));
-#279 = DIRECTION('NONE', (0, -1, 0));
-#280 = CARTESIAN_POINT('NONE', (0.08889999999999999, -0, -0.127));
-#281 = AXIS2_PLACEMENT_3D('NONE', #280, #279, #278);
-#282 = CIRCLE('NONE', #281, 0.0063499999999999945);
-#283 = DIRECTION('NONE', (0, 1, 0));
-#284 = VECTOR('NONE', #283, 1);
-#285 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0, -0.127));
-#286 = LINE('NONE', #285, #284);
-#287 = DIRECTION('NONE', (1, 0, 0.0000000000000022379298764097663));
-#288 = DIRECTION('NONE', (0, -1, 0));
-#289 = CARTESIAN_POINT('NONE', (0.08889999999999999, 0.008923630267041387, -0.127));
-#290 = AXIS2_PLACEMENT_3D('NONE', #289, #288, #287);
-#291 = CIRCLE('NONE', #290, 0.0063499999999999945);
-#292 = DIRECTION('NONE', (1, 0, 0.000000000000002237929876409761));
-#293 = DIRECTION('NONE', (0, -1, 0));
-#294 = CARTESIAN_POINT('NONE', (0.025399999999999992, -0, -0.127));
-#295 = AXIS2_PLACEMENT_3D('NONE', #294, #293, #292);
-#296 = CIRCLE('NONE', #295, 0.006350000000000008);
-#297 = DIRECTION('NONE', (0, 1, 0));
-#298 = VECTOR('NONE', #297, 1);
-#299 = CARTESIAN_POINT('NONE', (0.03175, 0, -0.127));
-#300 = LINE('NONE', #299, #298);
-#301 = DIRECTION('NONE', (1, 0, 0.000000000000002237929876409761));
-#302 = DIRECTION('NONE', (0, -1, 0));
-#303 = CARTESIAN_POINT('NONE', (0.025399999999999992, 0.008923630267041387, -0.127));
-#304 = AXIS2_PLACEMENT_3D('NONE', #303, #302, #301);
-#305 = CIRCLE('NONE', #304, 0.006350000000000008);
-#306 = DIRECTION('NONE', (1, 0, -0.0000000000000011189649382048806));
-#307 = DIRECTION('NONE', (0, -1, 0));
-#308 = CARTESIAN_POINT('NONE', (0.08889999999999998, -0, -0.025399999999999992));
-#309 = AXIS2_PLACEMENT_3D('NONE', #308, #307, #306);
-#310 = CIRCLE('NONE', #309, 0.006350000000000008);
-#311 = DIRECTION('NONE', (0, 1, 0));
-#312 = VECTOR('NONE', #311, 1);
-#313 = CARTESIAN_POINT('NONE', (0.09524999999999999, 0, -0.0254));
-#314 = LINE('NONE', #313, #312);
-#315 = DIRECTION('NONE', (1, 0, -0.0000000000000011189649382048806));
-#316 = DIRECTION('NONE', (0, -1, 0));
-#317 = CARTESIAN_POINT('NONE', (0.08889999999999998, 0.008923630267041387, -0.025399999999999992));
-#318 = AXIS2_PLACEMENT_3D('NONE', #317, #316, #315);
-#319 = CIRCLE('NONE', #318, 0.006350000000000008);
-#320 = DIRECTION('NONE', (0, 1, 0));
-#321 = VECTOR('NONE', #320, 1);
-#322 = CARTESIAN_POINT('NONE', (0.111125, 0, -0));
-#323 = LINE('NONE', #322, #321);
-#324 = DIRECTION('NONE', (-0.000000000000004475859752819553, 0, 1));
-#325 = DIRECTION('NONE', (0, 1, -0));
-#326 = CARTESIAN_POINT('NONE', (0.11112500000000003, 0.008923630267041387, -0.006349999999999966));
-#327 = AXIS2_PLACEMENT_3D('NONE', #326, #325, #324);
-#328 = CIRCLE('NONE', #327, 0.006349999999999966);
-#329 = DIRECTION('NONE', (0, -1, 0));
-#330 = VECTOR('NONE', #329, 1);
-#331 = CARTESIAN_POINT('NONE', (0.117475, 0.008923630267041387, -0.00635));
-#332 = LINE('NONE', #331, #330);
-#333 = DIRECTION('NONE', (1, 0, -0.000000000000005315083456473219));
-#334 = DIRECTION('NONE', (0, -1, 0));
-#335 = CARTESIAN_POINT('NONE', (0.11112500000000003, -0, -0.006349999999999966));
-#336 = AXIS2_PLACEMENT_3D('NONE', #335, #334, #333);
-#337 = CIRCLE('NONE', #336, 0.006349999999999966);
-#338 = DIRECTION('NONE', (1, 0, 0));
-#339 = VECTOR('NONE', #338, 1);
-#340 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#341 = LINE('NONE', #340, #339);
-#342 = DIRECTION('NONE', (-1, 0, 0));
-#343 = VECTOR('NONE', #342, 1);
-#344 = CARTESIAN_POINT('NONE', (0.11112500000000002, 0.008923630267041387, -0));
-#345 = LINE('NONE', #344, #343);
-#346 = DIRECTION('NONE', (0, 1, 0));
-#347 = VECTOR('NONE', #346, 1);
-#348 = CARTESIAN_POINT('NONE', (0.117475, 0, -0.14605));
-#349 = LINE('NONE', #348, #347);
-#350 = DIRECTION('NONE', (1, 0, 0.000000000000013427579258458719));
-#351 = DIRECTION('NONE', (-0, 1, 0));
-#352 = CARTESIAN_POINT('NONE', (0.11112500000000006, 0.008923630267041387, -0.1460500000000001));
-#353 = AXIS2_PLACEMENT_3D('NONE', #352, #351, #350);
-#354 = CIRCLE('NONE', #353, 0.006349999999999937);
-#355 = DIRECTION('NONE', (0, -1, 0));
-#356 = VECTOR('NONE', #355, 1);
-#357 = CARTESIAN_POINT('NONE', (0.111125, 0.008923630267041387, -0.1524));
-#358 = LINE('NONE', #357, #356);
-#359 = DIRECTION('NONE', (-0.000000000000008951719505639185, 0, -1));
-#360 = DIRECTION('NONE', (0, -1, -0));
-#361 = CARTESIAN_POINT('NONE', (0.11112500000000006, -0, -0.1460500000000001));
-#362 = AXIS2_PLACEMENT_3D('NONE', #361, #360, #359);
-#363 = CIRCLE('NONE', #362, 0.006349999999999909);
-#364 = DIRECTION('NONE', (0, 0, -1));
-#365 = VECTOR('NONE', #364, 1);
-#366 = CARTESIAN_POINT('NONE', (0.117475, 0, -0.0063499999999999945));
-#367 = LINE('NONE', #366, #365);
-#368 = DIRECTION('NONE', (0, 0, 1));
-#369 = VECTOR('NONE', #368, 1);
-#370 = CARTESIAN_POINT('NONE', (0.117475, 0.008923630267041387, -0.14604999999999993));
-#371 = LINE('NONE', #370, #369);
-#372 = DIRECTION('NONE', (-1, 0, -0.0000000000000002497689594206972));
-#373 = VECTOR('NONE', #372, 1);
-#374 = CARTESIAN_POINT('NONE', (0.11112500000001577, 0, -0.15239999999999998));
-#375 = LINE('NONE', #374, #373);
-#376 = DIRECTION('NONE', (1, -0.000000000000000015610559963793574, 0.0000000000000002497689594206972));
-#377 = VECTOR('NONE', #376, 1);
-#378 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0.1524));
-#379 = LINE('NONE', #378, #377);
-#380 = EDGE_CURVE('NONE', #5, #7, #95, .T.);
-#381 = EDGE_CURVE('NONE', #9, #11, #99, .T.);
-#382 = EDGE_CURVE('NONE', #9, #5, #103, .T.);
-#383 = EDGE_CURVE('NONE', #11, #7, #107, .T.);
-#384 = EDGE_CURVE('NONE', #13, #13, #112, .T.);
-#385 = EDGE_CURVE('NONE', #13, #15, #116, .T.);
-#386 = EDGE_CURVE('NONE', #15, #15, #121, .T.);
-#387 = EDGE_CURVE('NONE', #17, #17, #126, .T.);
-#388 = EDGE_CURVE('NONE', #17, #19, #130, .T.);
-#389 = EDGE_CURVE('NONE', #19, #19, #135, .T.);
-#390 = EDGE_CURVE('NONE', #21, #23, #139, .T.);
-#391 = EDGE_CURVE('NONE', #23, #25, #144, .T.);
-#392 = EDGE_CURVE('NONE', #25, #27, #148, .T.);
-#393 = EDGE_CURVE('NONE', #27, #21, #153, .T.);
-#394 = EDGE_CURVE('NONE', #27, #9, #157, .T.);
-#395 = EDGE_CURVE('NONE', #11, #25, #161, .T.);
-#396 = EDGE_CURVE('NONE', #29, #31, #165, .T.);
-#397 = EDGE_CURVE('NONE', #31, #33, #170, .T.);
-#398 = EDGE_CURVE('NONE', #33, #35, #174, .T.);
-#399 = EDGE_CURVE('NONE', #35, #29, #179, .T.);
-#400 = EDGE_CURVE('NONE', #5, #29, #183, .T.);
-#401 = EDGE_CURVE('NONE', #31, #7, #187, .T.);
-#402 = EDGE_CURVE('NONE', #35, #21, #191, .T.);
-#403 = EDGE_CURVE('NONE', #23, #33, #195, .T.);
-#404 = EDGE_CURVE('NONE', #37, #39, #199, .T.);
-#405 = EDGE_CURVE('NONE', #39, #41, #203, .T.);
-#406 = EDGE_CURVE('NONE', #43, #41, #207, .T.);
-#407 = EDGE_CURVE('NONE', #37, #43, #211, .T.);
-#408 = EDGE_CURVE('NONE', #39, #45, #216, .T.);
-#409 = EDGE_CURVE('NONE', #45, #47, #220, .T.);
-#410 = EDGE_CURVE('NONE', #41, #47, #225, .T.);
-#411 = EDGE_CURVE('NONE', #45, #49, #229, .T.);
-#412 = EDGE_CURVE('NONE', #49, #51, #233, .T.);
-#413 = EDGE_CURVE('NONE', #47, #51, #237, .T.);
-#414 = EDGE_CURVE('NONE', #49, #37, #242, .T.);
-#415 = EDGE_CURVE('NONE', #51, #43, #247, .T.);
-#416 = EDGE_CURVE('NONE', #53, #55, #251, .T.);
-#417 = EDGE_CURVE('NONE', #57, #59, #255, .T.);
-#418 = EDGE_CURVE('NONE', #57, #53, #259, .T.);
-#419 = EDGE_CURVE('NONE', #59, #55, #263, .T.);
-#420 = EDGE_CURVE('NONE', #61, #61, #268, .T.);
-#421 = EDGE_CURVE('NONE', #61, #63, #272, .T.);
-#422 = EDGE_CURVE('NONE', #63, #63, #277, .T.);
-#423 = EDGE_CURVE('NONE', #65, #65, #282, .T.);
-#424 = EDGE_CURVE('NONE', #65, #67, #286, .T.);
-#425 = EDGE_CURVE('NONE', #67, #67, #291, .T.);
-#426 = EDGE_CURVE('NONE', #69, #69, #296, .T.);
-#427 = EDGE_CURVE('NONE', #69, #71, #300, .T.);
-#428 = EDGE_CURVE('NONE', #71, #71, #305, .T.);
-#429 = EDGE_CURVE('NONE', #73, #73, #310, .T.);
-#430 = EDGE_CURVE('NONE', #73, #75, #314, .T.);
-#431 = EDGE_CURVE('NONE', #75, #75, #319, .T.);
-#432 = EDGE_CURVE('NONE', #77, #79, #323, .T.);
-#433 = EDGE_CURVE('NONE', #79, #81, #328, .T.);
-#434 = EDGE_CURVE('NONE', #81, #83, #332, .T.);
-#435 = EDGE_CURVE('NONE', #83, #77, #337, .T.);
-#436 = EDGE_CURVE('NONE', #53, #77, #341, .T.);
-#437 = EDGE_CURVE('NONE', #79, #55, #345, .T.);
-#438 = EDGE_CURVE('NONE', #85, #87, #349, .T.);
-#439 = EDGE_CURVE('NONE', #87, #89, #354, .T.);
-#440 = EDGE_CURVE('NONE', #89, #91, #358, .T.);
-#441 = EDGE_CURVE('NONE', #91, #85, #363, .T.);
-#442 = EDGE_CURVE('NONE', #83, #85, #367, .T.);
-#443 = EDGE_CURVE('NONE', #87, #81, #371, .T.);
-#444 = EDGE_CURVE('NONE', #91, #57, #375, .T.);
-#445 = EDGE_CURVE('NONE', #59, #89, #379, .T.);
-#446 = CARTESIAN_POINT('NONE', (-0.013986815133520694, -0.034925000000000025, -0));
-#447 = DIRECTION('NONE', (0, 0, 1));
-#448 = AXIS2_PLACEMENT_3D('NONE', #446, #447, $);
-#449 = PLANE('NONE', #448);
-#450 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.06032499999999999, -0.07620000000000002));
-#451 = DIRECTION('NONE', (0, -1, 0));
-#452 = AXIS2_PLACEMENT_3D('NONE', #450, #451, $);
-#453 = PLANE('NONE', #452);
-#454 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.03492500000000002, -0.15240000000000004));
-#455 = DIRECTION('NONE', (0, -0, -1));
-#456 = AXIS2_PLACEMENT_3D('NONE', #454, #455, $);
-#457 = PLANE('NONE', #456);
-#458 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.009525, -0.0762));
-#459 = DIRECTION('NONE', (-0, 1, 0));
-#460 = AXIS2_PLACEMENT_3D('NONE', #458, #459, $);
-#461 = PLANE('NONE', #460);
-#462 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.03810000000000001, -0.025400000000000006));
-#463 = DIRECTION('NONE', (-1, 0, -0));
-#464 = DIRECTION('NONE', (0, 0.0000000000000011189649382048832, -1));
-#465 = AXIS2_PLACEMENT_3D('NONE', #462, #463, #464);
-#466 = CYLINDRICAL_SURFACE('NONE', #465, 0.0063499999999999945);
-#467 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.03810000000000001, -0.127));
-#468 = DIRECTION('NONE', (-1, 0, -0));
-#469 = DIRECTION('NONE', (0, 0.0000000000000011189649382048857, -1));
-#470 = AXIS2_PLACEMENT_3D('NONE', #467, #468, #469);
-#471 = CYLINDRICAL_SURFACE('NONE', #470, 0.00634999999999998);
-#472 = CARTESIAN_POINT('NONE', (-0.018448630267041386, 0, -0));
-#473 = DIRECTION('NONE', (1, 0, 0));
-#474 = AXIS2_PLACEMENT_3D('NONE', #472, #473, $);
-#475 = PLANE('NONE', #474);
-#476 = CARTESIAN_POINT('NONE', (-0.009525, 0, -0));
-#477 = DIRECTION('NONE', (1, 0, 0));
-#478 = AXIS2_PLACEMENT_3D('NONE', #476, #477, $);
-#479 = PLANE('NONE', #478);
-#480 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.053975, -0.14605000000000004));
-#481 = DIRECTION('NONE', (1, 0, 0));
-#482 = DIRECTION('NONE', (0, -1, 0.000000000000004475859752819533));
-#483 = AXIS2_PLACEMENT_3D('NONE', #480, #481, #482);
-#484 = CYLINDRICAL_SURFACE('NONE', #483, 0.0063499999999999945);
-#485 = CARTESIAN_POINT('NONE', (-0.013986815133520692, -0.05397500000000001, -0.006349999999999988));
-#486 = DIRECTION('NONE', (1, 0, -0));
-#487 = DIRECTION('NONE', (0, 0.000000000000002237929876409769, 1));
-#488 = AXIS2_PLACEMENT_3D('NONE', #485, #486, #487);
-#489 = CYLINDRICAL_SURFACE('NONE', #488, 0.006349999999999988);
-#490 = CARTESIAN_POINT('NONE', (0, 0.004461815133520694, -0.0762));
-#491 = DIRECTION('NONE', (1, -0, 0));
-#492 = AXIS2_PLACEMENT_3D('NONE', #490, #491, $);
-#493 = PLANE('NONE', #492);
-#494 = CARTESIAN_POINT('NONE', (-0.000000000000000003996802888650563, -0.009524999999999997, -0.0762));
-#495 = DIRECTION('NONE', (0, 0, 1));
-#496 = DIRECTION('NONE', (0.00000000000000021664496663423743, 1, -0));
-#497 = AXIS2_PLACEMENT_3D('NONE', #494, #495, #496);
-#498 = CYLINDRICAL_SURFACE('NONE', #497, 0.018448630267041383);
-#499 = CARTESIAN_POINT('NONE', (-0.013986815133520694, -0.009525, -0.0762));
-#500 = DIRECTION('NONE', (0, -1, 0));
-#501 = AXIS2_PLACEMENT_3D('NONE', #499, #500, $);
-#502 = PLANE('NONE', #501);
-#503 = CARTESIAN_POINT('NONE', (-0.0000000000000000004440892098500626, -0.009524999999999999, -0.0762));
-#504 = DIRECTION('NONE', (0, -0, -1));
-#505 = DIRECTION('NONE', (-1, 0.00000000000000018649415636748036, -0));
-#506 = AXIS2_PLACEMENT_3D('NONE', #503, #504, #505);
-#507 = CYLINDRICAL_SURFACE('NONE', #506, 0.009525);
-#508 = CARTESIAN_POINT('NONE', (0, 0, -0.1524));
-#509 = DIRECTION('NONE', (0, 0, 1));
-#510 = AXIS2_PLACEMENT_3D('NONE', #508, #509, $);
-#511 = PLANE('NONE', #510);
-#512 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#513 = DIRECTION('NONE', (0, 0, 1));
-#514 = AXIS2_PLACEMENT_3D('NONE', #512, #513, $);
-#515 = PLANE('NONE', #514);
-#516 = CARTESIAN_POINT('NONE', (0.0587375, 0.004461815133520694, -0));
-#517 = DIRECTION('NONE', (0, 0, 1));
-#518 = AXIS2_PLACEMENT_3D('NONE', #516, #517, $);
-#519 = PLANE('NONE', #518);
-#520 = CARTESIAN_POINT('NONE', (0.117475, 0.004461815133520694, -0.07620000000000002));
-#521 = DIRECTION('NONE', (1, 0, 0));
-#522 = AXIS2_PLACEMENT_3D('NONE', #520, #521, $);
-#523 = PLANE('NONE', #522);
-#524 = CARTESIAN_POINT('NONE', (0.05873749999999999, 0.004461815133520693, -0.15239999999999998));
-#525 = DIRECTION('NONE', (0, -0, -1));
-#526 = AXIS2_PLACEMENT_3D('NONE', #524, #525, $);
-#527 = PLANE('NONE', #526);
-#528 = CARTESIAN_POINT('NONE', (0, 0.004461815133520694, -0.0762));
-#529 = DIRECTION('NONE', (-1, 0, 0));
-#530 = AXIS2_PLACEMENT_3D('NONE', #528, #529, $);
-#531 = PLANE('NONE', #530);
-#532 = CARTESIAN_POINT('NONE', (0.0254, 0.004461815133520694, -0.0254));
-#533 = DIRECTION('NONE', (0, -1, 0));
-#534 = DIRECTION('NONE', (1, 0, -0));
-#535 = AXIS2_PLACEMENT_3D('NONE', #532, #533, #534);
-#536 = CYLINDRICAL_SURFACE('NONE', #535, 0.0063500000000000015);
-#537 = CARTESIAN_POINT('NONE', (0.08889999999999999, 0.004461815133520694, -0.127));
-#538 = DIRECTION('NONE', (0, -1, 0));
-#539 = DIRECTION('NONE', (1, 0, 0.0000000000000022379298764097663));
-#540 = AXIS2_PLACEMENT_3D('NONE', #537, #538, #539);
-#541 = CYLINDRICAL_SURFACE('NONE', #540, 0.0063499999999999945);
-#542 = CARTESIAN_POINT('NONE', (0.025399999999999992, 0.004461815133520694, -0.127));
-#543 = DIRECTION('NONE', (0, -1, 0));
-#544 = DIRECTION('NONE', (1, 0, 0.000000000000002237929876409761));
-#545 = AXIS2_PLACEMENT_3D('NONE', #542, #543, #544);
-#546 = CYLINDRICAL_SURFACE('NONE', #545, 0.006350000000000008);
-#547 = CARTESIAN_POINT('NONE', (0.08889999999999998, 0.004461815133520694, -0.025399999999999992));
-#548 = DIRECTION('NONE', (0, -1, 0));
-#549 = DIRECTION('NONE', (1, 0, -0.0000000000000011189649382048806));
-#550 = AXIS2_PLACEMENT_3D('NONE', #547, #548, #549);
-#551 = CYLINDRICAL_SURFACE('NONE', #550, 0.006350000000000008);
-#552 = CARTESIAN_POINT('NONE', (0, 0, -0));
-#553 = DIRECTION('NONE', (0, 1, 0));
-#554 = AXIS2_PLACEMENT_3D('NONE', #552, #553, $);
-#555 = PLANE('NONE', #554);
-#556 = CARTESIAN_POINT('NONE', (0, 0.008923630267041387, -0));
-#557 = DIRECTION('NONE', (0, 1, 0));
-#558 = AXIS2_PLACEMENT_3D('NONE', #556, #557, $);
-#559 = PLANE('NONE', #558);
-#560 = CARTESIAN_POINT('NONE', (0.11112500000000003, 0.004461815133520694, -0.006349999999999966));
-#561 = DIRECTION('NONE', (0, 1, -0));
-#562 = DIRECTION('NONE', (-0.000000000000004475859752819553, 0, 1));
-#563 = AXIS2_PLACEMENT_3D('NONE', #560, #561, #562);
-#564 = CYLINDRICAL_SURFACE('NONE', #563, 0.006349999999999966);
-#565 = CARTESIAN_POINT('NONE', (0.11112500000000006, 0.004461815133520694, -0.1460500000000001));
-#566 = DIRECTION('NONE', (-0, 1, 0));
-#567 = DIRECTION('NONE', (1, 0, 0.000000000000013427579258458719));
-#568 = AXIS2_PLACEMENT_3D('NONE', #565, #566, #567);
-#569 = CYLINDRICAL_SURFACE('NONE', #568, 0.006349999999999937);
-#570 = ORIENTED_EDGE('NONE', *, *, #400, .T.);
-#571 = ORIENTED_EDGE('NONE', *, *, #396, .T.);
-#572 = ORIENTED_EDGE('NONE', *, *, #401, .T.);
-#573 = ORIENTED_EDGE('NONE', *, *, #380, .F.);
-#574 = EDGE_LOOP('NONE', (#570, #571, #572, #573));
-#575 = FACE_BOUND('NONE', #574, .T.);
-#576 = ADVANCED_FACE('NONE', (#575), #449, .T.);
-#577 = ORIENTED_EDGE('NONE', *, *, #402, .T.);
-#578 = ORIENTED_EDGE('NONE', *, *, #390, .T.);
-#579 = ORIENTED_EDGE('NONE', *, *, #403, .T.);
-#580 = ORIENTED_EDGE('NONE', *, *, #398, .T.);
-#581 = EDGE_LOOP('NONE', (#577, #578, #579, #580));
-#582 = FACE_BOUND('NONE', #581, .T.);
-#583 = ADVANCED_FACE('NONE', (#582), #453, .T.);
-#584 = ORIENTED_EDGE('NONE', *, *, #394, .T.);
-#585 = ORIENTED_EDGE('NONE', *, *, #381, .T.);
-#586 = ORIENTED_EDGE('NONE', *, *, #395, .T.);
-#587 = ORIENTED_EDGE('NONE', *, *, #392, .T.);
-#588 = EDGE_LOOP('NONE', (#584, #585, #586, #587));
-#589 = FACE_BOUND('NONE', #588, .T.);
-#590 = ADVANCED_FACE('NONE', (#589), #457, .T.);
-#591 = ORIENTED_EDGE('NONE', *, *, #382, .T.);
-#592 = ORIENTED_EDGE('NONE', *, *, #380, .T.);
-#593 = ORIENTED_EDGE('NONE', *, *, #383, .F.);
-#594 = ORIENTED_EDGE('NONE', *, *, #381, .F.);
-#595 = EDGE_LOOP('NONE', (#591, #592, #593, #594));
-#596 = FACE_BOUND('NONE', #595, .T.);
-#597 = ADVANCED_FACE('NONE', (#596), #461, .T.);
-#598 = ORIENTED_EDGE('NONE', *, *, #384, .T.);
-#599 = ORIENTED_EDGE('NONE', *, *, #386, .F.);
-#600 = EDGE_LOOP('NONE', (#598));
-#601 = FACE_BOUND('NONE', #600, .T.);
-#602 = EDGE_LOOP('NONE', (#599));
-#603 = FACE_BOUND('NONE', #602, .T.);
-#604 = ADVANCED_FACE('NONE', (#601, #603), #466, .F.);
-#605 = ORIENTED_EDGE('NONE', *, *, #387, .T.);
-#606 = ORIENTED_EDGE('NONE', *, *, #389, .F.);
-#607 = EDGE_LOOP('NONE', (#605));
-#608 = FACE_BOUND('NONE', #607, .T.);
-#609 = EDGE_LOOP('NONE', (#606));
-#610 = FACE_BOUND('NONE', #609, .T.);
-#611 = ADVANCED_FACE('NONE', (#608, #610), #471, .F.);
-#612 = ORIENTED_EDGE('NONE', *, *, #382, .F.);
-#613 = ORIENTED_EDGE('NONE', *, *, #394, .F.);
-#614 = ORIENTED_EDGE('NONE', *, *, #393, .T.);
-#615 = ORIENTED_EDGE('NONE', *, *, #402, .F.);
-#616 = ORIENTED_EDGE('NONE', *, *, #399, .T.);
-#617 = ORIENTED_EDGE('NONE', *, *, #400, .F.);
-#618 = ORIENTED_EDGE('NONE', *, *, #384, .F.);
-#619 = ORIENTED_EDGE('NONE', *, *, #387, .F.);
-#620 = EDGE_LOOP('NONE', (#612, #613, #614, #615, #616, #617));
-#621 = FACE_BOUND('NONE', #620, .T.);
-#622 = EDGE_LOOP('NONE', (#618));
-#623 = FACE_BOUND('NONE', #622, .T.);
-#624 = EDGE_LOOP('NONE', (#619));
-#625 = FACE_BOUND('NONE', #624, .T.);
-#626 = ADVANCED_FACE('NONE', (#621, #623, #625), #475, .F.);
-#627 = ORIENTED_EDGE('NONE', *, *, #401, .F.);
-#628 = ORIENTED_EDGE('NONE', *, *, #397, .T.);
-#629 = ORIENTED_EDGE('NONE', *, *, #403, .F.);
-#630 = ORIENTED_EDGE('NONE', *, *, #391, .T.);
-#631 = ORIENTED_EDGE('NONE', *, *, #395, .F.);
-#632 = ORIENTED_EDGE('NONE', *, *, #383, .T.);
-#633 = ORIENTED_EDGE('NONE', *, *, #386, .T.);
-#634 = ORIENTED_EDGE('NONE', *, *, #389, .T.);
-#635 = EDGE_LOOP('NONE', (#627, #628, #629, #630, #631, #632));
-#636 = FACE_BOUND('NONE', #635, .T.);
-#637 = EDGE_LOOP('NONE', (#633));
-#638 = FACE_BOUND('NONE', #637, .T.);
-#639 = EDGE_LOOP('NONE', (#634));
-#640 = FACE_BOUND('NONE', #639, .T.);
-#641 = ADVANCED_FACE('NONE', (#636, #638, #640), #479, .T.);
-#642 = ORIENTED_EDGE('NONE', *, *, #393, .F.);
-#643 = ORIENTED_EDGE('NONE', *, *, #392, .F.);
-#644 = ORIENTED_EDGE('NONE', *, *, #391, .F.);
-#645 = ORIENTED_EDGE('NONE', *, *, #390, .F.);
-#646 = EDGE_LOOP('NONE', (#642, #643, #644, #645));
-#647 = FACE_BOUND('NONE', #646, .T.);
-#648 = ADVANCED_FACE('NONE', (#647), #484, .T.);
-#649 = ORIENTED_EDGE('NONE', *, *, #399, .F.);
-#650 = ORIENTED_EDGE('NONE', *, *, #398, .F.);
-#651 = ORIENTED_EDGE('NONE', *, *, #397, .F.);
-#652 = ORIENTED_EDGE('NONE', *, *, #396, .F.);
-#653 = EDGE_LOOP('NONE', (#649, #650, #651, #652));
-#654 = FACE_BOUND('NONE', #653, .T.);
-#655 = ADVANCED_FACE('NONE', (#654), #489, .T.);
-#656 = ORIENTED_EDGE('NONE', *, *, #404, .T.);
-#657 = ORIENTED_EDGE('NONE', *, *, #405, .T.);
-#658 = ORIENTED_EDGE('NONE', *, *, #406, .F.);
-#659 = ORIENTED_EDGE('NONE', *, *, #407, .F.);
-#660 = EDGE_LOOP('NONE', (#656, #657, #658, #659));
-#661 = FACE_BOUND('NONE', #660, .T.);
-#662 = ADVANCED_FACE('NONE', (#661), #493, .T.);
-#663 = ORIENTED_EDGE('NONE', *, *, #408, .T.);
-#664 = ORIENTED_EDGE('NONE', *, *, #409, .T.);
-#665 = ORIENTED_EDGE('NONE', *, *, #410, .F.);
-#666 = ORIENTED_EDGE('NONE', *, *, #405, .F.);
-#667 = EDGE_LOOP('NONE', (#663, #664, #665, #666));
-#668 = FACE_BOUND('NONE', #667, .T.);
-#669 = ADVANCED_FACE('NONE', (#668), #498, .T.);
-#670 = ORIENTED_EDGE('NONE', *, *, #411, .T.);
-#671 = ORIENTED_EDGE('NONE', *, *, #412, .T.);
-#672 = ORIENTED_EDGE('NONE', *, *, #413, .F.);
-#673 = ORIENTED_EDGE('NONE', *, *, #409, .F.);
-#674 = EDGE_LOOP('NONE', (#670, #671, #672, #673));
-#675 = FACE_BOUND('NONE', #674, .T.);
-#676 = ADVANCED_FACE('NONE', (#675), #502, .T.);
-#677 = ORIENTED_EDGE('NONE', *, *, #414, .T.);
-#678 = ORIENTED_EDGE('NONE', *, *, #407, .T.);
-#679 = ORIENTED_EDGE('NONE', *, *, #415, .F.);
-#680 = ORIENTED_EDGE('NONE', *, *, #412, .F.);
-#681 = EDGE_LOOP('NONE', (#677, #678, #679, #680));
-#682 = FACE_BOUND('NONE', #681, .T.);
-#683 = ADVANCED_FACE('NONE', (#682), #507, .F.);
-#684 = ORIENTED_EDGE('NONE', *, *, #414, .F.);
-#685 = ORIENTED_EDGE('NONE', *, *, #411, .F.);
-#686 = ORIENTED_EDGE('NONE', *, *, #408, .F.);
-#687 = ORIENTED_EDGE('NONE', *, *, #404, .F.);
-#688 = EDGE_LOOP('NONE', (#684, #685, #686, #687));
-#689 = FACE_BOUND('NONE', #688, .T.);
-#690 = ADVANCED_FACE('NONE', (#689), #511, .F.);
-#691 = ORIENTED_EDGE('NONE', *, *, #406, .T.);
-#692 = ORIENTED_EDGE('NONE', *, *, #410, .T.);
-#693 = ORIENTED_EDGE('NONE', *, *, #413, .T.);
-#694 = ORIENTED_EDGE('NONE', *, *, #415, .T.);
-#695 = EDGE_LOOP('NONE', (#691, #692, #693, #694));
-#696 = FACE_BOUND('NONE', #695, .T.);
-#697 = ADVANCED_FACE('NONE', (#696), #515, .T.);
-#698 = ORIENTED_EDGE('NONE', *, *, #436, .T.);
-#699 = ORIENTED_EDGE('NONE', *, *, #432, .T.);
-#700 = ORIENTED_EDGE('NONE', *, *, #437, .T.);
-#701 = ORIENTED_EDGE('NONE', *, *, #416, .F.);
-#702 = EDGE_LOOP('NONE', (#698, #699, #700, #701));
-#703 = FACE_BOUND('NONE', #702, .T.);
-#704 = ADVANCED_FACE('NONE', (#703), #519, .T.);
-#705 = ORIENTED_EDGE('NONE', *, *, #442, .T.);
-#706 = ORIENTED_EDGE('NONE', *, *, #438, .T.);
-#707 = ORIENTED_EDGE('NONE', *, *, #443, .T.);
-#708 = ORIENTED_EDGE('NONE', *, *, #434, .T.);
-#709 = EDGE_LOOP('NONE', (#705, #706, #707, #708));
-#710 = FACE_BOUND('NONE', #709, .T.);
-#711 = ADVANCED_FACE('NONE', (#710), #523, .T.);
-#712 = ORIENTED_EDGE('NONE', *, *, #444, .T.);
-#713 = ORIENTED_EDGE('NONE', *, *, #417, .T.);
-#714 = ORIENTED_EDGE('NONE', *, *, #445, .T.);
-#715 = ORIENTED_EDGE('NONE', *, *, #440, .T.);
-#716 = EDGE_LOOP('NONE', (#712, #713, #714, #715));
-#717 = FACE_BOUND('NONE', #716, .T.);
-#718 = ADVANCED_FACE('NONE', (#717), #527, .T.);
-#719 = ORIENTED_EDGE('NONE', *, *, #418, .T.);
-#720 = ORIENTED_EDGE('NONE', *, *, #416, .T.);
-#721 = ORIENTED_EDGE('NONE', *, *, #419, .F.);
-#722 = ORIENTED_EDGE('NONE', *, *, #417, .F.);
-#723 = EDGE_LOOP('NONE', (#719, #720, #721, #722));
-#724 = FACE_BOUND('NONE', #723, .T.);
-#725 = ADVANCED_FACE('NONE', (#724), #531, .T.);
-#726 = ORIENTED_EDGE('NONE', *, *, #420, .T.);
-#727 = ORIENTED_EDGE('NONE', *, *, #422, .F.);
-#728 = EDGE_LOOP('NONE', (#726));
-#729 = FACE_BOUND('NONE', #728, .T.);
-#730 = EDGE_LOOP('NONE', (#727));
-#731 = FACE_BOUND('NONE', #730, .T.);
-#732 = ADVANCED_FACE('NONE', (#729, #731), #536, .F.);
-#733 = ORIENTED_EDGE('NONE', *, *, #423, .T.);
-#734 = ORIENTED_EDGE('NONE', *, *, #425, .F.);
-#735 = EDGE_LOOP('NONE', (#733));
-#736 = FACE_BOUND('NONE', #735, .T.);
-#737 = EDGE_LOOP('NONE', (#734));
-#738 = FACE_BOUND('NONE', #737, .T.);
-#739 = ADVANCED_FACE('NONE', (#736, #738), #541, .F.);
-#740 = ORIENTED_EDGE('NONE', *, *, #426, .T.);
-#741 = ORIENTED_EDGE('NONE', *, *, #428, .F.);
-#742 = EDGE_LOOP('NONE', (#740));
-#743 = FACE_BOUND('NONE', #742, .T.);
-#744 = EDGE_LOOP('NONE', (#741));
-#745 = FACE_BOUND('NONE', #744, .T.);
-#746 = ADVANCED_FACE('NONE', (#743, #745), #546, .F.);
-#747 = ORIENTED_EDGE('NONE', *, *, #429, .T.);
-#748 = ORIENTED_EDGE('NONE', *, *, #431, .F.);
-#749 = EDGE_LOOP('NONE', (#747));
-#750 = FACE_BOUND('NONE', #749, .T.);
-#751 = EDGE_LOOP('NONE', (#748));
-#752 = FACE_BOUND('NONE', #751, .T.);
-#753 = ADVANCED_FACE('NONE', (#750, #752), #551, .F.);
-#754 = ORIENTED_EDGE('NONE', *, *, #418, .F.);
-#755 = ORIENTED_EDGE('NONE', *, *, #444, .F.);
-#756 = ORIENTED_EDGE('NONE', *, *, #441, .T.);
-#757 = ORIENTED_EDGE('NONE', *, *, #442, .F.);
-#758 = ORIENTED_EDGE('NONE', *, *, #435, .T.);
-#759 = ORIENTED_EDGE('NONE', *, *, #436, .F.);
-#760 = ORIENTED_EDGE('NONE', *, *, #420, .F.);
-#761 = ORIENTED_EDGE('NONE', *, *, #423, .F.);
-#762 = ORIENTED_EDGE('NONE', *, *, #426, .F.);
-#763 = ORIENTED_EDGE('NONE', *, *, #429, .F.);
-#764 = EDGE_LOOP('NONE', (#754, #755, #756, #757, #758, #759));
-#765 = FACE_BOUND('NONE', #764, .T.);
-#766 = EDGE_LOOP('NONE', (#760));
-#767 = FACE_BOUND('NONE', #766, .T.);
-#768 = EDGE_LOOP('NONE', (#761));
-#769 = FACE_BOUND('NONE', #768, .T.);
-#770 = EDGE_LOOP('NONE', (#762));
-#771 = FACE_BOUND('NONE', #770, .T.);
-#772 = EDGE_LOOP('NONE', (#763));
-#773 = FACE_BOUND('NONE', #772, .T.);
-#774 = ADVANCED_FACE('NONE', (#765, #767, #769, #771, #773), #555, .F.);
-#775 = ORIENTED_EDGE('NONE', *, *, #437, .F.);
-#776 = ORIENTED_EDGE('NONE', *, *, #433, .T.);
-#777 = ORIENTED_EDGE('NONE', *, *, #443, .F.);
-#778 = ORIENTED_EDGE('NONE', *, *, #439, .T.);
-#779 = ORIENTED_EDGE('NONE', *, *, #445, .F.);
-#780 = ORIENTED_EDGE('NONE', *, *, #419, .T.);
-#781 = ORIENTED_EDGE('NONE', *, *, #422, .T.);
-#782 = ORIENTED_EDGE('NONE', *, *, #425, .T.);
-#783 = ORIENTED_EDGE('NONE', *, *, #428, .T.);
-#784 = ORIENTED_EDGE('NONE', *, *, #431, .T.);
-#785 = EDGE_LOOP('NONE', (#775, #776, #777, #778, #779, #780));
-#786 = FACE_BOUND('NONE', #785, .T.);
-#787 = EDGE_LOOP('NONE', (#781));
-#788 = FACE_BOUND('NONE', #787, .T.);
-#789 = EDGE_LOOP('NONE', (#782));
-#790 = FACE_BOUND('NONE', #789, .T.);
-#791 = EDGE_LOOP('NONE', (#783));
-#792 = FACE_BOUND('NONE', #791, .T.);
-#793 = EDGE_LOOP('NONE', (#784));
-#794 = FACE_BOUND('NONE', #793, .T.);
-#795 = ADVANCED_FACE('NONE', (#786, #788, #790, #792, #794), #559, .T.);
-#796 = ORIENTED_EDGE('NONE', *, *, #435, .F.);
-#797 = ORIENTED_EDGE('NONE', *, *, #434, .F.);
-#798 = ORIENTED_EDGE('NONE', *, *, #433, .F.);
-#799 = ORIENTED_EDGE('NONE', *, *, #432, .F.);
-#800 = EDGE_LOOP('NONE', (#796, #797, #798, #799));
-#801 = FACE_BOUND('NONE', #800, .T.);
-#802 = ADVANCED_FACE('NONE', (#801), #564, .T.);
-#803 = ORIENTED_EDGE('NONE', *, *, #441, .F.);
-#804 = ORIENTED_EDGE('NONE', *, *, #440, .F.);
-#805 = ORIENTED_EDGE('NONE', *, *, #439, .F.);
-#806 = ORIENTED_EDGE('NONE', *, *, #438, .F.);
-#807 = EDGE_LOOP('NONE', (#803, #804, #805, #806));
-#808 = FACE_BOUND('NONE', #807, .T.);
-#809 = ADVANCED_FACE('NONE', (#808), #569, .T.);
-#810 = CLOSED_SHELL('NONE', (#576, #583, #590, #597, #604, #611, #626, #641, #648, #655));
-#811 = CLOSED_SHELL('NONE', (#662, #669, #676, #683, #690, #697));
-#812 = CLOSED_SHELL('NONE', (#704, #711, #718, #725, #732, #739, #746, #753, #774, #795, #802, #809));
-#813 = MANIFOLD_SOLID_BREP('NONE', #810);
-#814 = MANIFOLD_SOLID_BREP('NONE', #811);
-#815 = MANIFOLD_SOLID_BREP('NONE', #812);
-#816 = APPLICATION_CONTEXT('configuration controlled 3D design of mechanical parts and assemblies');
-#817 = PRODUCT_DEFINITION_CONTEXT('part definition', #816, 'design');
-#818 = PRODUCT('UNIDENTIFIED_PRODUCT', 'NONE', $, ());
-#819 = PRODUCT_DEFINITION_FORMATION('', $, #818);
-#820 = PRODUCT_DEFINITION('design', $, #819, #817);
-#821 = PRODUCT_DEFINITION_SHAPE('NONE', $, #820);
-#822 = ADVANCED_BREP_SHAPE_REPRESENTATION('NONE', (#815), #3);
-#823 = SHAPE_DEFINITION_REPRESENTATION(#821, #822);
-#824 = PRODUCT('UNIDENTIFIED_PRODUCT', 'NONE', $, ());
-#825 = PRODUCT_DEFINITION_FORMATION('', $, #824);
-#826 = PRODUCT_DEFINITION('design', $, #825, #817);
-#827 = PRODUCT_DEFINITION_SHAPE('NONE', $, #826);
-#828 = ADVANCED_BREP_SHAPE_REPRESENTATION('NONE', (#814), #3);
-#829 = SHAPE_DEFINITION_REPRESENTATION(#827, #828);
-#830 = PRODUCT('UNIDENTIFIED_PRODUCT', 'NONE', $, ());
-#831 = PRODUCT_DEFINITION_FORMATION('', $, #830);
-#832 = PRODUCT_DEFINITION('design', $, #831, #817);
-#833 = PRODUCT_DEFINITION_SHAPE('NONE', $, #832);
-#834 = ADVANCED_BREP_SHAPE_REPRESENTATION('NONE', (#813), #3);
-#835 = SHAPE_DEFINITION_REPRESENTATION(#833, #834);
-ENDSEC;
-END-ISO-10303-21;