rewrote basic functionality to C. there are no colors just yet

18 files changed, 1154 insertions, 3986 deletions

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
deleted file mode 100644
index 98e44ee..0000000
--- a/.github/dependabot.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
deleted file mode 100644
index 63e65ae..0000000
--- a/.github/workflows/ci.yml
+++ /dev/null
@@ -1,32 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ main, master ]
-  pull_request:
-    branches: [ main, master ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Install Rust
-      uses: dtolnay/rust-toolchain@stable
-    
-    - name: Check formatting
-      run: cargo fmt -- --check
-    
-    - name: Run clippy
-      run: cargo clippy --all-targets -- -D warnings
-    
-    - name: Run tests
-      run: cargo test --all-targets --verbose
-    
-    - name: Build
-      run: cargo build --verbose
diff --git a/.github/workflows/package-win.yml b/.github/workflows/package-win.yml
deleted file mode 100644
index 53ea743..0000000
--- a/.github/workflows/package-win.yml
+++ /dev/null
@@ -1,285 +0,0 @@
-name: Windows Installer Packaging (Inno Setup)
-
-on:
-  release:
-    types: [released]
-  workflow_dispatch:
-    inputs:
-      tag_name:
-        description: 'Release Tag (e.g., v1.0.0). Leave empty to use "latest".'
-        required: false
-        default: ''
-
-jobs:
-  package-windows:
-    runs-on: windows-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Get Version from Cargo.toml
-        id: get_version
-        shell: pwsh
-        run: |
-          $VersionLine = Get-Content Cargo.toml | Select-String '^version\s*=\s*"(.*)"'
-          if ($VersionLine.Matches.Success) {
-            $Version = $VersionLine.Matches.Groups[1].Value
-            Write-Host "Found version in Cargo.toml: $Version"
-            "version=$Version" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
-          } else {
-            Write-Error "Could not find version in Cargo.toml"
-            exit 1
-          }
-
-      - name: Determine Release Tag
-        id: get_tag
-        shell: pwsh
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          $TAG = "${{ inputs.tag_name }}"
-          if (-not $TAG) { $TAG = "${{ github.event.release.tag_name }}" }
-          
-          if (-not $TAG) { 
-            Write-Host "No tag provided, fetching latest release..."
-            $TAG = $(gh release view --json tagName --jq .tagName) 
-          }
-          
-          if (-not $TAG) {
-            Write-Error "Could not determine release tag."
-            exit 1
-          }
-          
-          Write-Host "Using Tag: $TAG"
-          "tag=$TAG" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
-
-      - name: Download Release Assets
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          $TAG = "${{ steps.get_tag.outputs.tag }}"
-          $Version = "${{ steps.get_version.outputs.version }}"
-          
-          # Download the raw binaries
-          gh release download $TAG -p "mikusays-windows-x86_64-$Version.exe"
-          gh release download $TAG -p "mikusays-windows-aarch64-$Version.exe"
-          
-          # Rename to standard names for the Inno Script
-          mv "mikusays-windows-x86_64-$Version.exe" "mikusays-windows-x86_64.exe"
-          mv "mikusays-windows-aarch64-$Version.exe" "mikusays-windows-aarch64.exe"
-
-      - name: Generate Inno Setup Script
-        shell: pwsh
-        run: |
-          $Version = "${{ steps.get_version.outputs.version }}"
-          $InstallerName = "mikusays-windows-inst-any-$Version"
-          
-          Write-Host "Generating Inno Setup script for version: $Version"
-          
-          $issContent = @'
-          [Setup]
-          AppName=mikusays
-          AppVersion=__VERSION__
-          AppCopyright=2025 xxanqw
-          AppPublisher=xxanqw
-          AppPublisherURL=https://xxanqw.pp.ua/
-          AppSupportURL=https://github.com/xxanqw/mikusays/issues
-          AppUpdatesURL=https://github.com/xxanqw/mikusays/releases/latest
-          
-          AppId={{A0ED7972-D08B-48CB-8331-729D1001FF16}
-          
-          DefaultDirName={localappdata}\Programs\mikusays
-          DefaultGroupName=Mikusays
-          DisableProgramGroupPage=yes
-          PrivilegesRequired=lowest
-          
-          ; -- Output Configuration --
-          OutputBaseFilename=__OUTFILE__
-          OutputDir=.
-          Compression=lzma2/ultra64
-          SolidCompression=yes
-          
-          ; -- Architecture Configuration --
-          ArchitecturesInstallIn64BitMode=x64compatible arm64
-          ArchitecturesAllowed=x64compatible arm64
-          
-          ChangesEnvironment=yes
-          
-          [Languages]
-          Name: "english"; MessagesFile: "compiler:Default.isl"
-          
-          [Files]
-          Source: "mikusays-windows-x86_64.exe"; DestDir: "{app}"; DestName: "mikusays.exe"; Check: IsX64; Flags: ignoreversion
-          Source: "mikusays-windows-aarch64.exe"; DestDir: "{app}"; DestName: "mikusays.exe"; Check: IsARM64; Flags: ignoreversion
-          
-          [Icons]
-          Name: "{group}\Mikusays"; Filename: "{app}\mikusays.exe"
-          Name: "{group}\Uninstall Mikusays"; Filename: "{uninstallexe}"
-          
-          [Code]
-          function IsX64: Boolean;
-          begin
-            Result := Is64BitInstallMode and (ProcessorArchitecture = paX64);
-          end;
-          
-          function IsARM64: Boolean;
-          begin
-            Result := Is64BitInstallMode and (ProcessorArchitecture = paARM64);
-          end;
-          
-          const
-            VC_REDIST_X64_URL = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
-            VC_REDIST_ARM64_URL = 'https://aka.ms/vs/17/release/vc_redist.arm64.exe';
-            
-          var
-            DownloadPage: TDownloadWizardPage;
-          
-          procedure InitializeWizard;
-          begin
-            DownloadPage := CreateDownloadPage(SetupMessage(msgWizardPreparing), SetupMessage(msgPreparingDesc), nil);
-          end;
-          
-          function NextButtonClick(CurPageID: Integer): Boolean;
-          var
-            RedistUrl, RedistFile: String;
-            ResultCode: Integer;
-          begin
-            Result := True;
-            
-            if CurPageID = wpReady then
-            begin
-              DownloadPage.Clear;
-              
-              if IsARM64 then
-                RedistUrl := VC_REDIST_ARM64_URL
-              else
-                RedistUrl := VC_REDIST_X64_URL;
-                
-              RedistFile := 'vc_redist.exe';
-              
-              DownloadPage.Add(RedistUrl, RedistFile, '');
-              DownloadPage.Show;
-              
-              try
-                try
-                  DownloadPage.Download; 
-                  Exec(ExpandConstant('{tmp}\' + RedistFile), '/install /quiet /norestart', '', SW_HIDE, ewWaitUntilTerminated, ResultCode);
-                except
-                  if MsgBox('Download of Visual C++ Redistributable failed: ' + GetExceptionMessage + #13#10#13#10 + 'Do you want to continue installation anyway?', mbError, MB_YESNO) = IDNO then
-                    Result := False;
-                end;
-              finally
-                DownloadPage.Hide;
-              end;
-            end;
-          end;
-          
-          function NeedsAddPath(Param: string): boolean;
-          var
-            OrigPath: string;
-          begin
-            if not RegQueryStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath) then
-            begin
-              Result := True;
-              exit;
-            end;
-            Result := Pos(';' + Param + ';', ';' + OrigPath + ';') = 0;
-          end;
-          
-          procedure RemovePath(Param: string);
-          var
-            OrigPath: string;
-            P: Integer;
-          begin
-            if not RegQueryStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath) then
-              exit;
-              
-            P := Pos(';' + Param + ';', OrigPath);
-            if P > 0 then
-            begin
-              Delete(OrigPath, P + 1, Length(Param) + 1);
-              RegWriteExpandStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath);
-              exit;
-            end;
-            
-            if Pos(Param + ';', OrigPath) = 1 then
-            begin
-              Delete(OrigPath, 1, Length(Param) + 1);
-              RegWriteExpandStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath);
-              exit;
-            end;
-            
-            P := Pos(';' + Param, OrigPath);
-            if (P > 0) and (P = Length(OrigPath) - Length(Param)) then
-            begin
-              Delete(OrigPath, P, Length(Param) + 1);
-              RegWriteExpandStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath);
-            end;
-          end;
-          
-          procedure CurStepChanged(CurStep: TSetupStep);
-          var
-            OrigPath: string;
-          begin
-            if CurStep = ssPostInstall then
-            begin
-              if NeedsAddPath(ExpandConstant('{app}')) then
-              begin
-                if RegQueryStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath) then
-                begin
-                  if OrigPath = '' then
-                    OrigPath := ExpandConstant('{app}')
-                  else
-                    OrigPath := OrigPath + ';' + ExpandConstant('{app}');
-                end
-                else
-                  OrigPath := ExpandConstant('{app}');
-                  
-                RegWriteExpandStringValue(HKEY_CURRENT_USER, 'Environment', 'Path', OrigPath);
-              end;
-            end;
-          end;
-          
-          procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
-          begin
-            if CurUninstallStep = usUninstall then
-            begin
-              RemovePath(ExpandConstant('{app}'));
-            end;
-          end;
-          '@
-          
-          $issContent = $issContent.Replace("__VERSION__", $Version)
-          $issContent = $issContent.Replace("__OUTFILE__", $InstallerName)
-          
-          Set-Content -Path "installer.iss" -Value $issContent
-
-      - name: List workspace contents for debug
-        shell: pwsh
-        run: |
-          Write-Host "-- Workspace Contents --"
-          Get-ChildItem -File | ForEach-Object { Write-Host $_.Name }
-
-      - name: Compile Installer
-        shell: cmd
-        run: '"C:\Program Files (x86)\Inno Setup 6\ISCC.exe" installer.iss'
-
-      - name: Upload Installer to Release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          $TAG = "${{ steps.get_tag.outputs.tag }}"
-          $Version = "${{ steps.get_version.outputs.version }}"
-          
-          # With OutputDir=. the file is in root
-          $UploadFile = "mikusays-windows-inst-any-$Version.exe"
-          
-          if (-not (Test-Path $UploadFile)) {
-             Write-Error "Could not find compiled installer at $UploadFile"
-             Get-ChildItem
-             exit 1
-          }
-          
-          gh release upload $TAG $UploadFile --clobber
diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml
deleted file mode 100644
index 7c1867c..0000000
--- a/.github/workflows/package.yml
+++ /dev/null
@@ -1,170 +0,0 @@
-name: Build Packages
-permissions:
-  contents: read
-
-on:
-  release:
-    types: [created]
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        description: 'Release tag to attach packages to (e.g., v0.1.3)'
-        required: false
-        type: string
-
-jobs:
-  build-deb:
-    name: Build DEB Package (${{ matrix.arch }})
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - arch: x86_64
-            target: x86_64-unknown-linux-gnu
-          - arch: aarch64
-            target: aarch64-unknown-linux-gnu
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
-
-      - name: Install cross-compilation tools
-        if: matrix.arch == 'aarch64'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu
-
-      - name: Install cargo-deb
-        run: cargo install cargo-deb
-
-      - name: Build DEB package
-        run: cargo deb --target ${{ matrix.target }}
-        env:
-          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
-
-      - name: Find DEB package
-        id: find-deb
-        run: |
-          DEB_PATH=$(find target/${{ matrix.target }}/debian -name "*.deb" | head -n 1)
-          echo "path=$DEB_PATH" >> $GITHUB_OUTPUT
-          VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].version')
-          DEB_NAME="mikusays-debian-${{ matrix.arch }}-${VERSION}.deb"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "name=$DEB_NAME" >> $GITHUB_OUTPUT
-
-      - name: Upload DEB artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: deb-package-${{ matrix.arch }}
-          path: ${{ steps.find-deb.outputs.path }}
-
-      - name: Upload to release
-        if: github.event_name == 'release' || github.event.inputs.release_tag
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: ${{ github.event.release.tag_name || github.event.inputs.release_tag }}
-        run: |
-          install -m 0644 "${{ steps.find-deb.outputs.path }}" \
-            "$RUNNER_TEMP/${{ steps.find-deb.outputs.name }}"
-          gh release upload "$RELEASE_TAG" \
-            "$RUNNER_TEMP/${{ steps.find-deb.outputs.name }}" \
-            --repo "$GITHUB_REPOSITORY" \
-            --clobber
-
-  build-rpm:
-    name: Build RPM Package (${{ matrix.arch }})
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - arch: x86_64
-            target: x86_64-unknown-linux-gnu
-          - arch: aarch64
-            target: aarch64-unknown-linux-gnu
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
-
-      - name: Install cross-compilation tools
-        if: matrix.arch == 'aarch64'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu
-
-      - name: Install cargo-generate-rpm
-        run: cargo install cargo-generate-rpm
-
-      - name: Build release binary
-        run: cargo build --release --target ${{ matrix.target }}
-        env:
-          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
-
-      - name: Strip binary
-        run: |
-          if [ "${{ matrix.arch }}" = "aarch64" ]; then
-            aarch64-linux-gnu-strip target/${{ matrix.target }}/release/mikusays
-          else
-            strip target/${{ matrix.target }}/release/mikusays
-          fi
-
-      - name: Generate RPM package
-        run: cargo generate-rpm --target ${{ matrix.target }}
-
-      - name: Find RPM package
-        id: find-rpm
-        run: |
-          RPM_PATH=$(find target/${{ matrix.target }}/generate-rpm -name "*.rpm" | head -n 1)
-          echo "path=$RPM_PATH" >> $GITHUB_OUTPUT
-          VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].version')
-          RPM_NAME="mikusays-redhat-${{ matrix.arch }}-${VERSION}.rpm"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "name=$RPM_NAME" >> $GITHUB_OUTPUT
-
-      - name: Upload RPM artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: rpm-package-${{ matrix.arch }}
-          path: ${{ steps.find-rpm.outputs.path }}
-
-      - name: Upload to release
-        if: github.event_name == 'release' || github.event.inputs.release_tag
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: ${{ github.event.release.tag_name || github.event.inputs.release_tag }}
-        run: |
-          install -m 0644 "${{ steps.find-rpm.outputs.path }}" \
-            "$RUNNER_TEMP/${{ steps.find-rpm.outputs.name }}"
-          gh release upload "$RELEASE_TAG" \
-            "$RUNNER_TEMP/${{ steps.find-rpm.outputs.name }}" \
-            --repo "$GITHUB_REPOSITORY" \
-            --clobber
-
-  notify-package-repository:
-    name: Notify package repository
-    runs-on: ubuntu-latest
-    needs: [build-deb, build-rpm]
-    if: github.event_name == 'release' || github.event.inputs.release_tag
-    permissions:
-      contents: read
-    steps:
-      - name: Dispatch exact release tag
-        env:
-          GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
-          RELEASE_TAG: ${{ github.event.release.tag_name || github.event.inputs.release_tag }}
-        run: |
-          if ! gh api --method POST repos/xxanqw/apt-repository/dispatches \
-            --raw-field event_type=new-release \
-            --field "client_payload[tag_name]=$RELEASE_TAG"; then
-            echo "::warning::Could not dispatch apt-repository; its daily schedule will publish the release. Check RELEASE_TOKEN if immediate updates are required."
-          fi
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
deleted file mode 100644
index 8ed17a4..0000000
--- a/.github/workflows/release.yml
+++ /dev/null
@@ -1,265 +0,0 @@
-name: Cross-platform Build
-
-on:
-  push:
-    tags: [ 'v*' ]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-jobs:
-  extract-version:
-    name: Extract Version
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{ steps.get_version.outputs.version }}
-      version_valid: ${{ steps.validate_version.outputs.valid }}
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Get version from Cargo.toml
-      id: get_version
-      run: |
-        VERSION=$(grep '^version =' Cargo.toml | sed -E 's/version = "([^"]+)"/\1/')
-        echo "Extracted version: $VERSION"
-        echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-    - name: Validate SemVer
-      id: validate_version
-      run: |
-        VERSION=${{ steps.get_version.outputs.version }}
-        # Comprehensive SemVer validation regex
-        # Supports: MAJOR.MINOR.PATCH-PRERELEASE+BUILD
-        # Where PRERELEASE can be: alpha, beta, rc.1, etc.
-        # Where BUILD can be: build.123, sha.abc123, etc.
-        if [[ ! $VERSION =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?$ ]]; then
-          echo "Error: Version '$VERSION' is not a valid SemVer string"
-          echo "valid=false" >> $GITHUB_OUTPUT
-          exit 1
-        else
-          echo "Version '$VERSION' is valid SemVer"
-          echo "valid=true" >> $GITHUB_OUTPUT
-        fi
-
-  build-windows:
-    name: Build Windows
-    runs-on: windows-latest
-    needs: extract-version
-    strategy:
-      matrix:
-        target: 
-          - x86_64-pc-windows-msvc
-          - aarch64-pc-windows-msvc
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Install Rust
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: ${{ matrix.target }}
-    
-    - name: Build
-      run: cargo build --release --target ${{ matrix.target }}
-    
-    - name: Prepare artifact
-      run: |
-        mkdir artifacts
-        $arch = "${{ matrix.target }}".Split('-')[0]
-        $version = "${{ needs.extract-version.outputs.version }}"
-        copy "target\${{ matrix.target }}\release\mikusays.exe" "artifacts\mikusays-windows-$arch-$version.exe"
-    
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: mikusays-windows-${{ matrix.target }}
-        path: artifacts\*
-  build-linux:
-    name: Build Linux
-    runs-on: ubuntu-latest
-    needs: extract-version
-    strategy:
-      matrix:
-        include:
-          - target: x86_64-unknown-linux-gnu
-            arch: x64
-          - target: aarch64-unknown-linux-gnu  
-            arch: arm64
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Install Rust
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: ${{ matrix.target }}
-    
-    - name: Install cross-compilation tools
-      if: matrix.target == 'aarch64-unknown-linux-gnu'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y gcc-aarch64-linux-gnu
-        echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
-    
-    - name: Build
-      run: cargo build --release --target ${{ matrix.target }}
-    
-    - name: Strip binary
-      run: |
-        if [[ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]]; then
-          aarch64-linux-gnu-strip target/${{ matrix.target }}/release/mikusays
-        else
-          strip target/${{ matrix.target }}/release/mikusays
-        fi
-    
-    - name: Prepare artifact
-      run: |
-        mkdir -p artifacts staging
-        version="${{ needs.extract-version.outputs.version }}"
-        stem="mikusays-linux-${{ matrix.arch }}-$version"
-        cp target/${{ matrix.target }}/release/mikusays "staging/$stem"
-        chmod 755 "staging/$stem"
-        tar -C staging -czf "artifacts/$stem.tar.gz" "$stem"
-
-    - name: Verify artifact
-      run: |
-        version="${{ needs.extract-version.outputs.version }}"
-        stem="mikusays-linux-${{ matrix.arch }}-$version"
-        extract_dir="$(mktemp -d)"
-        tar -tzf "artifacts/$stem.tar.gz" | grep -Fx "$stem"
-        tar -xzf "artifacts/$stem.tar.gz" -C "$extract_dir"
-        test -x "$extract_dir/$stem"
-    
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: mikusays-linux-${{ matrix.arch }}
-        path: artifacts/*
-  build-macos:
-    name: Build macOS
-    runs-on: macos-latest
-    needs: extract-version
-    strategy:
-      matrix:
-        include:
-          - target: x86_64-apple-darwin
-            arch: x64
-          - target: aarch64-apple-darwin
-            arch: arm64
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Install Rust
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: ${{ matrix.target }}
-    
-    - name: Build
-      run: cargo build --release --target ${{ matrix.target }}
-    
-    - name: Strip binary
-      run: strip target/${{ matrix.target }}/release/mikusays
-    
-    - name: Prepare artifact
-      run: |
-        mkdir -p artifacts staging
-        version="${{ needs.extract-version.outputs.version }}"
-        stem="mikusays-macos-${{ matrix.arch }}-$version"
-        cp target/${{ matrix.target }}/release/mikusays "staging/$stem"
-        chmod 755 "staging/$stem"
-        tar -C staging -czf "artifacts/$stem.tar.gz" "$stem"
-
-    - name: Verify artifact
-      run: |
-        version="${{ needs.extract-version.outputs.version }}"
-        stem="mikusays-macos-${{ matrix.arch }}-$version"
-        extract_dir="$(mktemp -d)"
-        tar -tzf "artifacts/$stem.tar.gz" | grep -Fx "$stem"
-        tar -xzf "artifacts/$stem.tar.gz" -C "$extract_dir"
-        test -x "$extract_dir/$stem"
-    
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: mikusays-macos-${{ matrix.arch }}
-        path: artifacts/*
-
-  create-release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    needs: [extract-version, build-windows, build-linux, build-macos]
-    if: startsWith(github.ref, 'refs/tags/v') && needs.extract-version.outputs.version_valid == 'true'
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Download all artifacts
-      uses: actions/download-artifact@v4
-      with:
-        path: artifacts
-        merge-multiple: true
-    
-    - name: Display structure of downloaded files
-      run: ls -R artifacts
-    
-    - name: Create Release
-      uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64 # v3.0.3
-      with:
-        files: artifacts/mikusays-*
-        draft: false
-        prerelease: false
-        generate_release_notes: true
-        body: |
-          ## Downloads
-          
-          ### Windows
-          - **x64**: `mikusays-windows-x86_64-${{ needs.extract-version.outputs.version }}.exe`
-          - **ARM64**: `mikusays-windows-aarch64-${{ needs.extract-version.outputs.version }}.exe`
-
-          ### Windows Installer
-          - **Any**: `mikusays-windows-inst-any-${{ needs.extract-version.outputs.version }}.exe`
-
-          ### Linux (tar.gz)
-          - **x64**: `mikusays-linux-x64-${{ needs.extract-version.outputs.version }}.tar.gz`
-          - **ARM64**: `mikusays-linux-arm64-${{ needs.extract-version.outputs.version }}.tar.gz`
-
-          ### Debian Package
-          - **x64 Debian Package**: `mikusays-debian-x86_64-${{ needs.extract-version.outputs.version }}.deb`
-          - **ARM64 Debian Package**: `mikusays-debian-aarch64-${{ needs.extract-version.outputs.version }}.deb`
-
-          ### RedHat (RPM) Package
-          - **x64 RPM Package**: `mikusays-redhat-x86_64-${{ needs.extract-version.outputs.version }}.rpm`
-          - **ARM64 RPM Package**: `mikusays-redhat-aarch64-${{ needs.extract-version.outputs.version }}.rpm`
-
-          ### Repository for Debian / Ubuntu / Fedora / RHEL / CentOS
-          Information on how to add it available here https://apt.xxanqw.pp.ua
-          
-          ### macOS (tar.gz)
-          - **Intel (x64)**: `mikusays-macos-x64-${{ needs.extract-version.outputs.version }}.tar.gz`
-          - **Apple Silicon (ARM64)**: `mikusays-macos-arm64-${{ needs.extract-version.outputs.version }}.tar.gz`
-          
-          ## Usage
-          ```bash
-          # Download and extract the appropriate archive on Linux/macOS:
-          archive="mikusays-linux-x64-${{ needs.extract-version.outputs.version }}.tar.gz"
-          tar -xzf "$archive"
-          
-          # Run the program:
-          "./${archive%.tar.gz}" "Hello, World!"
-
-          # If Gatekeeper blocks an unsigned macOS binary:
-          xattr -d com.apple.quarantine "./${archive%.tar.gz}"
-          ```
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-    - name: Notify package managers
-      env:
-        GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
-        RELEASE_TAG: v${{ needs.extract-version.outputs.version }}
-      run: |
-        for repository in xxanqw/scoop-bucket xxanqw/homebrew-mikusays; do
-          if ! gh api --method POST "repos/$repository/dispatches" \
-            --raw-field event_type=new-release \
-            --field "client_payload[tag_name]=$RELEASE_TAG"; then
-            echo "::warning::Could not dispatch $repository; its four-hour schedule will pick up the release. Check RELEASE_TOKEN if immediate updates are required."
-          fi
-        done
diff --git a/.gitignore b/.gitignore
index 4b18fc9..17fb64e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,30 +1,3 @@
-# Rust
-/target/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Build artifacts
-*.exe
-*.dll
-*.so
-*.dylib
-
-# Backup files
-*.bak
-*.backup
-
-# Log files
-*.log
-
-# Temporary files
-*.tmp
-*.temp
+# build stuff 
+obj/
+build/
diff --git a/Cargo.lock b/Cargo.lock
deleted file mode 100644
index 8626b3d..0000000
--- a/Cargo.lock
+++ /dev/null
@@ -1,682 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "anstream"
-version = "0.6.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
-dependencies = [
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
-dependencies = [
- "anstyle",
- "once_cell_polyfill",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
-[[package]]
-name = "bitflags"
-version = "2.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
-
-[[package]]
-name = "clap"
-version = "4.5.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6899ea499e3fb9305a65d5ebf6e3d2248c5fab291f300ad0a704fbe142eae31a"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.5.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b12c8b680195a62a8364d16b8447b01b6c2c8f9aaf68bee653be34d4245e238"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.5.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
-
-[[package]]
-name = "convert_case"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
-dependencies = [
- "unicode-segmentation",
-]
-
-[[package]]
-name = "crossterm"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
-dependencies = [
- "bitflags",
- "crossterm_winapi",
- "derive_more",
- "document-features",
- "mio",
- "parking_lot",
- "rustix",
- "signal-hook",
- "signal-hook-mio",
- "winapi",
-]
-
-[[package]]
-name = "crossterm_winapi"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "derive_more"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "document-features"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
-dependencies = [
- "litrs",
-]
-
-[[package]]
-name = "errno"
-version = "0.3.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
-dependencies = [
- "libc",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
-dependencies = [
- "cfg-if",
- "libc",
- "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
-]
-
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
-[[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
-[[package]]
-name = "libc"
-version = "0.2.174"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
-
-[[package]]
-name = "litrs"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
-
-[[package]]
-name = "lock_api"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
-
-[[package]]
-name = "mikusays"
-version = "0.1.5"
-dependencies = [
- "clap",
- "crossterm",
- "rand",
- "unicode-width",
- "winapi",
-]
-
-[[package]]
-name = "mio"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
-dependencies = [
- "libc",
- "log",
- "wasi 0.11.1+wasi-snapshot-preview1",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "once_cell_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
-
-[[package]]
-name = "parking_lot"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.95"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "r-efi"
-version = "5.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
-
-[[package]]
-name = "rand"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
-dependencies = [
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "rustix"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "signal-hook"
-version = "0.3.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
-[[package]]
-name = "signal-hook-mio"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34db1a06d485c9142248b7a054f034b349b212551f3dfd19c94d45a754a217cd"
-dependencies = [
- "libc",
- "mio",
- "signal-hook",
-]
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "smallvec"
-version = "1.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
-
-[[package]]
-name = "strsim"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
-name = "syn"
-version = "2.0.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
-
-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
-[[package]]
-name = "unicode-width"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-
-[[package]]
-name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
-
-[[package]]
-name = "wasi"
-version = "0.14.2+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
-dependencies = [
- "wit-bindgen-rt",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.2",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
-dependencies = [
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
-[[package]]
-name = "wit-bindgen-rt"
-version = "0.39.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.8.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
diff --git a/Cargo.toml b/Cargo.toml
deleted file mode 100644
index 3bf4f61..0000000
--- a/Cargo.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-[package]
-name = "mikusays"
-version = "0.1.5"
-edition = "2024"
-description = "A \"cowsay\" clone with Hatsune Miku ASCII art and speech bubbles."
-license = "MIT"
-
-[package.metadata.deb]
-maintainer = "Ivan Potiienko <[email protected]>"
-copyright = "2025, xxanqw <[email protected]>"
-license-file = ["LICENSE", "4"]
-extended-description = """\
-A cowsay clone featuring Hatsune Miku ASCII art with speech bubbles. \
-Create fun terminal messages with various Miku styles."""
-depends = "$auto"
-section = "utils"
-priority = "optional"
-assets = [
-    ["target/release/mikusays", "usr/bin/", "755"],
-    ["README.md", "usr/share/doc/mikusays/", "644"],
-]
-
-[package.metadata.generate-rpm]
-assets = [
-    { source = "target/release/mikusays", dest = "/usr/bin/mikusays", mode = "755" },
-    { source = "README.md", dest = "/usr/share/doc/mikusays/README.md", mode = "644" },
-]
-
-[dependencies]
-crossterm = "0.29"
-unicode-width = "0.2.2"
-rand = "0.9.2"
-clap = { version = "4.5.57", features = ["derive"] }
-# sysinfo removed; using env var heuristics instead
-
-# Windows console API to enable virtual terminal processing (ANSI)
-winapi = { version = "0.3", features = ["consoleapi", "wincon", "processenv", "handleapi", "winbase"] }
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..8509a27
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,28 @@
+CC = gcc
+CFLAGS = -Wall -Wextra -O2 -pipe 
+TARGET = build/mikusays
+SRC = $(wildcard src/*.c)
+OBJ = $(SRC:%.c=obj/%.o)
+PREFIX = /usr/local
+
+$(TARGET): $(OBJ)
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -o $(TARGET) $(OBJ) $(LDLIBS)
+
+install: $(TARGET)
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	install -m 755 $(TARGET) $(DESTDIR)$(PREFIX)/bin/$(notdir $(TARGET))
+
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/$(notdir $(TARGET))
+
+obj/%.o: %.c
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(TARGET) $(OBJ)
+
+run: 
+	make
+	build/mikusaysc "this is a test"
diff --git a/README.md b/README.md
index a182761..4524665 100644
--- a/README.md
+++ b/README.md
@@ -1,146 +1,36 @@
 <div align=center>
 
-<img width="500px" src="https://github.com/user-attachments/assets/f8f42b9f-43c9-4c0b-914c-fc2bce5a438d" />
-
 
 # MikuSays 🎤
 
 A `cowsay` clone with Hatsune Miku ASCII art and speech bubbles.  
-
-**NOW WITH**  
-<img height=24 src="https://cdn.xserv.pp.ua/files/css/COLORS.svg" alt="COLORS">
+(originally written in rust, rewriten in C)
 
 
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/xxanqw/mikusays?style=for-the-badge)](https://github.com/xxanqw/mikusays/releases/latest)
-[![AUR Package Version](https://img.shields.io/aur/version/mikusays?style=for-the-badge)](https://aur.archlinux.org/packages/mikusays)
-
 </div>
 
 ## Usage
 
 ```bash
-Usage: mikusays [OPTIONS] [TEXT]
+mikusays "Hello, World!" # Chooses random style
 
-Arguments:
-  [TEXT]  Text to display in the speech bubble
+mikusays "World is Mine!" --style 4
 
-Options:
-  -s, --style <STYLE>            Style of the Miku art. A random one is chosen if not specified
-  -l, --list                     List all available art styles with their indices
-      --rainbow                  Apply a smooth rainbow gradient across the ASCII art
-      --saturation <SATURATION>  Saturation level for rainbow gradient (0-100) [default: 100]
-      --brightness <BRIGHTNESS>  Brightness level for rainbow gradient (0-100) [default: 50]
-      --color <COLOR>            Override with a single solid color
-      --gradient <START:END>     Define a custom two-color gradient (e.g., --gradient red:blue)
-      --no-color                 Disable all coloring (respects NO_COLOR environment variable)
-  -h, --help                     Print help
-  -V, --version                  Print version
+mikusays --help
 ```
 
 ## Installation
 
-### Arch Linux
-```bash
-yay -S mikusays
-paru -S mikusays
-```
-
-### Debian / Ubuntu / Fedora / RHEL / CentOS
-The repository and instructions available here: https://apt.xxanqw.pp.ua
-
-### macOS (or Linux if using Homebrew)
-```bash
-brew tap xxanqw/mikusays
-brew install mikusays
-```
-
-### Windows  
-- **Using Scoop**:
-  
-  ```bash
-  scoop bucket add extras
-  scoop bucket add xxanqw-bucket https://github.com/xxanqw/scoop-bucket
-  scoop update
-  scoop install mikusays
-  ```
-- **Using Installer**:
-  
-  Download `mikusays-windows-inst-any-x.x.x.exe` from [Latest release page](https://github.com/xxanqw/mikusays/releases/latest)
-
----
-
-### Download from [Releases](https://github.com/xxanqw/mikusays/releases):
-
-- **Windows**: `mikusays-windows-*.exe`
-    - Small note for Windows that application depends on `vcredist2022`  
-      (installing with scoop and installer resolve this dependency automatically)
-- **Linux**: `mikusays-linux-*.tar.gz`
-- **macOS**: `mikusays-macos-*.tar.gz`
-
-Linux and macOS archives preserve the executable permission. Extract and run one with:
-
+build from source:
 ```bash
-archive="mikusays-linux-x64-VERSION.tar.gz"
-tar -xzf "$archive"
-"./${archive%.tar.gz}" "Hello, World!"
+make
 ```
-
-The macOS binaries are currently unsigned. If Gatekeeper quarantines an extracted binary,
-remove the quarantine attribute before running it:
-
-```bash
-xattr -d com.apple.quarantine ./mikusays-macos-arm64-VERSION
-```
-
-Or build from source:
+install it:
 ```bash
-cargo build --release
-```
+sudo make install
+``` 
+it puts it at /usr/local/bin/mikusays
 
 ## Development
 
-### Release automation
-
-Tagged releases build the platform binaries first, then trigger the Scoop bucket.
-After all DEB and RPM assets have uploaded, the package workflow triggers the APT/RPM
-repository with the exact tag. The `RELEASE_TOKEN` Actions secret must be able to create
-repository dispatch events in `xxanqw/scoop-bucket`, `xxanqw/homebrew-mikusays`, and
-`xxanqw/apt-repository`. If that token expires, the release remains successful and the
-downstream repositories recover through their scheduled update workflows. Uploads to the
-MikuSays release itself use the built-in workflow token and do not depend on this secret.
-
-The distribution repositories keep scheduled and manual workflows as recovery paths if
-an event dispatch fails.
-
-1. Fork repository
-2. Clone your fork
-3. Implement your changes
-4. If needed, write tests (it would be great)
-5. Run your code with your changes
-   ```bash
-   cargo run -- [your implemented methods, or just text if it's ASCII only].
-   ```
-7. Run the tests
-   ```bash
-   cargo test
-   ```
-8. Check your code quality with:
-   ```bash
-   cargo clippy -- -D warnings
-   ```
-   Fix any errors that appear
-   
-10. Finally, run the formatter:
-    ```bash
-    cargo fmt
-    ```
-11. Commit and push your changes
-12. Open a pull request
-
-Now you're a contributor!
-
-<div align=center>
-
-<img height="124" src="https://github.com/user-attachments/assets/f3d4e4e8-0fa4-40a1-bc89-aafbbd896a73" />
-
-</div>
+idk open a pull request 
diff --git a/defs/all.h b/defs/all.h
new file mode 100644
index 0000000..e876d91
--- /dev/null
+++ b/defs/all.h
@@ -0,0 +1,15 @@
+#ifndef all_h
+#define all_h
+
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
+
+
+//COLORS.C 
+void Void(void); //function that does FUCKING NOTHING BECAUSE MY STUPID LSP THINK I'M NOT USING THIS FUCKING FILE AND GIVES ME A WARNINGGENROENIGGHUIOAGHUIHUIAUHIDFG
+
+
+#endif
diff --git a/defs/mikuart.h b/defs/mikuart.h
new file mode 100644
index 0000000..4616f0a
--- /dev/null
+++ b/defs/mikuart.h
@@ -0,0 +1,737 @@
+#ifndef miku_h
+#define miku_h
+
+#include <stddef.h>
+
+//my lsp thinks this is c++ and tells gives me 624 warnings. how do i tell it this is not c++11 and it's c99 instead  
+static char *mikuart_0[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣷⣀⡤⠤⠤⠤⠤⢤⣄⣀⡀⠀⠀⠀⣀⣀⡀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⣾⣿⣟⡵⠚⠉⠀⠤⠂⠀⠀⠀⠀⠀⠀⠉⠓⠦⣾⣿⣿⣿⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⣴⣿⣿⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⣄⠀⠀⠀⠘⢦⡙⢷⣜⣿⣿⣆⠀⠀⠀",
+    "⠀⠀⢺⣿⣿⡟⠁⠀⢀⠀⠀⡆⠀⠀⠀⠀⠀⠈⢣⡀⠀⠀⠀⠙⡼⡍⡘⣿⣿⣆⠀⠀",
+    "⠀⠀⠀⢹⡟⠀⠀⢀⠇⢀⡼⡇⠀⠀⠀⣤⡀⠀⠀⢱⡀⠀⠀⠀⠸⣿⡴⡘⣿⣿⣆⠀",
+    "⠀⠀⠀⣼⡅⠀⠀⣘⢀⡾⢥⣿⣰⠀⠀⡟⢷⡀⢷⣄⢷⡀⠀⠀⠀⢻⡞⣧⣿⡿⠋⠀",
+    "⠀⠀⢠⡿⡇⠀⠀⣽⣾⣤⣤⣈⢿⠆⠀⡇⠘⠹⣿⡝⢮⣇⠀⠀⠀⢸⣿⣿⡟⢱⠀⠀",
+    "⠀⠀⢸⠀⡏⡇⠀⣿⢱⠿⣿⣻⡝⢿⣄⢳⢐⣶⣾⣷⣾⣿⠀⠀⡇⠘⣿⠉⡄⠸⡀⠀",
+    "⠀⠀⡏⢸⣧⣷⠀⣿⠸⢯⣉⡾⠁⠈⠻⣾⡜⣗⠿⣭⡏⣿⠀⢀⣧⡀⣿⡄⡇⠈⡇⠀",
+    "⠀⢠⠇⠸⢱⡟⣆⣿⣄⠀⠀⠀⠀⠀⠀⠈⠁⠑⠖⠚⠀⣾⠀⣼⣿⠙⠇⡇⠇⠀⢇⠀",
+    "⠀⢸⠀⠀⢸⠀⠘⢾⣿⣗⣦⣄⣀⠰⠤⠄⠀⠀⣀⣠⢴⢧⠾⠿⠃⠀⠀⡇⠀⠀⢸⠀",
+    "⠀⡏⢀⠀⢸⠀⠀⠀⠀⠙⠿⣣⣾⣭⢿⣫⡿⠻⡍⠠⠟⠁⠀⠀⠀⠀⠀⡇⢀⠀⢸⠀",
+    "⢠⠁⢸⠀⢸⠀⠀⠀⠀⢀⣴⣿⣧⢸⢿⠇⣵⣼⣿⡄⠀⠀⠀⠀⠀⠀⠀⡇⡎⠀⠘⡇",
+    "⢸⠀⠸⡄⡇⠀⠀⠀⣠⣾⣿⣿⡏⣸⣸⠈⠀⢹⣿⣿⣆⠀⠀⠀⠀⠀⠀⡿⡇⠀⠀⡇",
+    "⡄⠀⠀⣇⢰⠀⠀⠸⢿⣿⣿⢞⠇⣟⢸⠅⡆⠘⣿⣿⣿⣧⠀⠀⠀⠀⠀⣇⡇⠀⠀⢠",
+    "⢁⢆⠀⠸⣼⠀⠀⠘⠋⢩⣾⣧⣶⣿⣿⣆⣼⣿⣿⣿⣻⠿⡄⠀⠀⠀⠀⣿⠁⠐⠀⢸",
+    "⠘⡌⣆⠀⢻⡆⠀⠀⠀⠘⠫⣟⣿⣿⣿⣿⣿⣻⣯⠟⠉⠋⠁⠀⠀⠀⢠⡏⢀⠷⠀⢸",
+    "⠀⠙⢿⣗⢔⢷⡀⠀⠀⠀⠀⢸⣶⣶⣿⢳⣶⣖⡇⠀⠀⠀⠀⠀⠀⠀⡼⢀⢎⡇⢠⡇",
+    "⠀⠀⠀⠙⠻⠲⠽⠄⠀⠀⠀⠀⣿⣿⣿⢸⣿⣿⡇⠀⠀⠀⠀⠀⢀⣞⢔⣃⣼⡴⠋⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢾⡻⠿⢨⡿⣿⡇⠀⠀⠀⠀⠀⠉⠉⠉⠉⠁⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_1[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣾⣿⠷⠒⠛⠉⠛⠓⠦⣤⣶⣳⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣠⠖⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣻⠽⠀⢀⣠⡔⣦⣄⠀⠰⣟⢻⡁⠉⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠸⠉⠙⠲⢷⣄⡈⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⠁⣠⠖⠋⠘⣇⡇⠈⠳⡄⠘⢷⣷⠀⠀⢹⡄⠀⠀⠀⠀⠀⠀⠀",
+    "⠨⠷⣶⡦⢄⡈⠑⢦⡈⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⡿⢡⡼⣓⠁⠀⠀⢿⣿⠒⠢⢽⡄⠀⠸⣧⠀⠀⢻⡀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠉⠙⠒⠯⢤⣽⡀⠉⠲⣄⠀⠀⠀⠀⠀⠀⠀⡼⢹⠇⣾⠻⣁⡟⠀⠀⠀⠻⢾⣉⡾⣷⠠⢐⣿⡆⠂⠀⢳⡀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⠦⡀⠑⢄⠀⠀⢀⣀⡼⢁⣾⣿⡏⠀⠀⢠⠤⣤⣀⡀⠀⠉⠀⢸⣼⣿⣿⣿⣷⠸⡀⠈⢧⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣄⠳⣾⣿⣿⣷⣼⡭⣿⣧⡀⠀⡼⠀⠀⢸⠀⠀⠀⢀⣼⣿⣿⠟⢻⡀⣧⠀⠘⣇⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣇⠀⠀⢸⠀⣀⣠⣾⣿⡟⠁⠀⠈⡇⢸⡄⠀⢹⡆⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⡿⠉⣛⣿⣯⠿⣻⡿⠛⢿⣿⠓⠀⠀⠀⣇⠈⣇⠀⠈⣿⡀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡼⠉⣽⡹⣏⣟⣻⣿⣷⢴⡿⢩⣿⡞⠹⡄⠀⠀⣹⣇⠀⠀⠀⣟⠀⢿⠀⢃⠸⣧⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠃⢰⣯⢳⡝⣦⢻⣿⢏⡾⠁⢸⠀⠷⢶⠿⣿⣿⣿⣿⠀⠀⢀⣏⠰⠌⠀⠸⡐⡽⡄⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡞⠀⣾⢧⡻⣜⡧⠟⠛⣾⠁⢀⡿⠒⠎⢦⢹⣿⣿⣿⣿⣧⠀⢰⡇⠨⢀⡐⠀⡇⣝⣳⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠃⢀⡿⣧⣛⣾⢿⡄⢀⣽⣠⣏⠀⠢⠄⡈⢺⣿⣿⣿⣿⣿⡆⣸⠃⠀⡀⢧⠀⢸⢰⠽⡆",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢠⠊⣹⢧⢯⡽⣮⢿⣿⣿⣿⣿⣧⣀⣤⣴⣿⣿⣯⣿⢿⣿⣿⡿⠀⠁⡀⢸⠆⢸⣹⢚⣷",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣯⡏⠀⣿⣛⡮⣗⠿⣦⣽⠛⠿⣿⣿⣿⣿⣿⢻⣿⣷⣿⣿⣿⣿⢃⡀⠁⡀⢸⢣⠸⡜⣷⢺",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⠀⢸⢸⡿⡼⣭⡻⣵⡿⣯⣙⢚⣧⣴⠒⣋⣡⣴⣟⠳⠴⢿⣿⣾⠀⠠⠀⡼⢣⢸⡕⣻⣿",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡄⢸⡇⠏⣷⡳⡽⢶⡟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠘⠀⣯⡄⠀⠄⣏⣛⢦⠽⣱⣟",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⡘⣿⣄⢹⣳⡽⠋⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠹⣶⠀⢸⢣⡝⢮⡹⣥⡟",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⣼⡹⢾⠏⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠀⠀⠀⠀⠙⢧⣜⡳⣚⢧⢳⡽⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠻⢿⠂⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⠀⠀⠀⠀⠀⢹⢶⡙⣮⠟⠁⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⠿⢛⡿⠿⠿⠋⠀⠀⠀⠀⠀⠀⠀⠀⢸⡧⠟⠁⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_2[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣀⣀⠀⠀⣀⡠⠴⠒⠚⠉⠉⠓⠒⠦⣄⣶⠒⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡷⢬⣉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠠⡌⠻⣧⢻⣧⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣖⠗⡋⢹⠀⠀⢰⡄⠀⠀⢸⣷⡀⠀⣠⠽⣆⢼⣇⢻⣸⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡜⣡⣶⢋⡏⠙⢢⣏⣇⠀⠀⠈⣇⡵⡏⠀⠀⢹⡏⢾⣿⠃⢿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⢿⢻⣏⣿⡇⡄⣾⠀⠹⡄⠄⠀⡇⠀⠹⣤⠈⠹⣿⣾⢸⠀⢘⣷⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣯⣿⣽⣿⣷⢸⡗⠦⣄⡹⣼⣄⣿⣴⠛⠹⡄⡇⣿⣿⠾⠚⢹⢿⢽⣽⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣞⣾⣿⢿⣯⢻⢻⡴⠞⠁⠈⠻⣿⣌⡉⠓⣿⣰⡿⠀⠀⠀⠸⡜⡾⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢀⡴⣡⠊⢸⣹⠁⠈⠙⣾⡄⠁⠀⢰⠛⠉⠉⠉⢳⣀⣿⣿⠃⠀⠀⣀⣀⣧⣿⡞⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⣠⠋⡴⠁⠀⠸⢿⣤⣤⣤⣹⣿⣷⣶⣾⣷⣶⣶⣺⣋⣽⣿⣷⠶⠟⠛⠋⢧⠀⠀⠸⡜⣷⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⡜⠁⡰⠁⠀⠀⢠⡿⠀⠀⠀⠉⠉⠉⠙⢻⡟⣹⣿⠃⣿⠋⠁⠀⠀⠀⠀⠀⠸⡄⠀⠀⢣⠹⣧⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⢠⠏⡀⢠⠇⠀⠀⢠⡿⠁⠀⠀⠀⠀⣤⣶⡴⠚⢻⠡⣸⠀⢹⣆⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠸⡄⢻⣇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢀⡏⣼⠁⢸⠀⠀⠀⣾⠃⠀⠀⠀⠀⠀⢻⣿⣧⣀⣬⠋⠁⠀⣠⣿⣶⣆⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠈⣿⡀⠀⠀⠀⠀⠀",
+    "⠀⠀⣸⣸⣿⠀⡇⠀⢰⣸⡟⠀⠀⠀⣀⣠⠴⠚⣟⣻⣧⣯⣗⣤⣾⣿⣿⡿⠋⠀⠀⠀⠀⣸⣤⠀⠀⠀⡇⡆⢻⠃⠀⠀⠀⠀⠀",
+    "⠀⠀⣿⡿⢸⡀⣇⠀⣸⣿⡁⠀⣾⣻⡁⣀⣤⣶⠟⠋⠉⠛⢿⣋⣻⡏⠉⠀⠀⠀⠀⠀⢰⣿⡇⠀⠀⠀⣷⡇⣸⡄⠀⠀⠀⠀⠀",
+    "⠀⠀⠿⠇⠀⢧⢸⠀⣿⡿⠇⠀⠈⠛⠛⠋⠉⠀⠀⠀⠀⠀⡟⠀⣿⠇⠀⠀⠀⠀⠀⢠⣿⣿⡇⠀⠀⣰⡿⣧⣿⠃⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢿⣄⣹⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡇⠀⣿⠀⠀⠀⠀⠀⠀⣸⡿⢸⠁⢠⣾⠋⢰⣿⡏⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠉⠛⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣶⣶⡿⠀⠀⠀⠀⠀⠀⠉⠁⢸⣶⡟⠁⠀⠾⠟⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_3[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡖⣉⡬⣷⣦⠶⠶⠞⠙⡦⠖⠒⠒⠒⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⢤⣠⠔⢦⡀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡞⢉⣩⢯⡴⠃⢀⡴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠓⢦⡀⠀⠀⠀⠀⠀⠀⠀⠻⡀⠀⠁⠀⢀⡇⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⡿⠉⠲⣵⠘⡆⠴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢦⡀⠀⠀⣀⣀⣀⠀⠙⣆⠀⡠⠎⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⡤⠞⠓⠓⠲⢄⡘⠃⠹⡄⠀⠀⠀⢀⡀⠀⠀⠀⡀⠀⠀⠀⢀⠀⠀⠈⢳⡀⠹⡄⢀⡇⢀⡞⠀⠀⠈⡏⠁⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⣀⡤⠽⠂⠀⠧⡄⣀⢀⡏⣇⠀⠀⢀⡿⣄⠀⢀⠈⣇⠀⠀⠀⠙⡆⢁⡟⢁⡞⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⣠⠞⠁⠀⠀⠀⠀⠀⠘⢧⡤⠖⢒⠿⡆⠹⡬⠻⣦⡘⢆⠀⡼⠀⣈⡽⠫⣀⠈⡆⠀⠀⠀⠓⡼⢀⡿⠚⠉⠉⢹⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡖⣱⠁⠱⡞⠱⡤⣄⡉⠀⠹⡇⠀⠁⢀⣠⠎⠙⢷⠀⠀⠀⢠⠃⠀⠀⠀⣠⠤⠚⠃⠀⠀⠀⠀⠀⠀",
+    "⠀⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠏⠀⡇⠀⢀⠟⡆⠳⡄⢙⣦⠀⠀⠀⠾⣍⡀⠀⠀⢸⡀⠀⢀⡏⠀⠀⡴⠋⠈⠉⠓⠦⡀⠀⠀⠀⠀⠀",
+    "⢸⠁⢀⡴⠂⠀⠀⠀⠀⡀⠀⡏⠀⢰⢁⡔⠋⠀⢳⠀⠙⡍⢰⠒⠚⡇⠀⠀⠙⠂⠀⣼⠃⣠⡜⠀⠀⡞⠁⠀⠀⠀⠀⠀⠈⠳⡄⠀⠀⠀",
+    "⣧⢞⡏⠀⠀⠀⠀⠀⡼⣇⠀⡇⠀⢸⠎⠀⡤⠖⠒⡇⠀⢳⠈⠓⠚⠁⠀⠀⠀⢀⡤⠿⠋⣰⠃⠀⣜⠁⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀",
+    "⠀⢸⠀⠀⠀⠀⠀⠀⡇⠈⠳⠇⠀⠀⠀⡞⠁⠀⠀⠹⡄⠈⣇⡀⠀⠀⣀⡤⠞⠉⠀⠀⢀⡇⠀⣰⠃⠙⢦⠀⠀⠀⠀⠀⣤⣄⡀⢸⠀⠀",
+    "⠀⢸⡀⠀⠀⠀⠀⠀⡇⠀⠀⠀⢀⣔⣲⠟⠲⣄⣀⡠⠟⢻⢁⣏⡟⢩⡁⢀⡟⠦⣀⣀⣾⣄⣰⠃⠀⠀⠀⠱⡄⠀⠀⠀⠀⡇⠹⠃⠀⠀",
+    "⠀⠀⠑⠦⣄⡀⠀⠀⣧⠀⠀⢀⠏⣷⠃⠀⠀⠀⠉⠳⣄⡞⢯⡘⡖⣆⠳⣼⠀⠀⠉⠳⣴⠃⠉⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀⢳⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠉⠉⠉⠁⠀⠀⢸⠀⠛⠀⠀⠀⠀⠀⢀⣈⡽⣶⡵⠃⠈⠙⠺⣄⠤⠀⠀⠘⢦⡀⠀⠀⠀⠠⠟⠚⡇⠀⠀⢰⡏⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠦⠤⠤⠒⠖⢊⡝⠀⠀⠀⠀⠀⠀⠀⠀⢛⠒⠦⠖⠋⠉⠀⠀⠀⠀⠀⣠⣞⡥⠤⠤⠞⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠤⡯⠤⠤⠤⠤⠤⠤⠤⠤⠤⢼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⣇⠀⣄⠀⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠞⠁⠉⠉⠉⠉⢦⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_4[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⡖⠓⠶⢦⢄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⣀⡘⣿⣿⣟⠙⢶⣄⡀⠀⠉⠳⠤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡠⠖⠛⠉⠀⠀⠀⠀⠈⠿⣿⡛⣦⠤⠤⣉⡓⠀⠀⠀⠀⠙⠓⠤⣀⡀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⣶⣶⣤⠖⠁⠀⠀⠀⠀⢀⣀⣤⣄⠀⠀⢿⣴⣿⣿⣶⣤⣍⡓⠶⣤⣀⡀⠀⠀⠀⠉⠑⠒⠤⠄⢀⡀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠏⢩⣿⣧⣼⡁⠀⣀⠀⠀⢠⣤⠀⠈⠙⢯⠳⣆⠀⠹⣝⢻⢿⠛⠁⠉⠲⢌⡉⠙⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠀⣸⣿⠛⠉⠉⠉⢁⠀⠀⠀⠻⠓⢄⠀⠀⠀⠈⠁⠀⠉⢿⣿⣇⠀⠀⠀⠀⠉⠳⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢠⡇⠀⡿⢁⠀⠀⠀⠀⠈⢣⠀⠀⢸⣆⡀⠀⠀⠀⠀⠀⠀⠙⢮⢻⣿⡄⠀⠀⠀⠀⠀⠀⠈⠑⠶⢄⣀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⣼⣡⣫⠏⠀⠀⠀⢀⡏⠳⣄⣎⢇⠙⠛⣦⣤⣀⠀⠀⠀⠈⣧⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠳⠤⣄",
+    "⠀⠀⠀⠀⠀⠀⠀⢰⠃⢠⢻⢣⣿⠀⡀⣤⡄⢸⡇⠀⠈⠙⠾⣦⡀⠸⣿⣿⣿⡶⣦⠀⣿⣼⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈",
+    "⠀⠀⠀⠀⠀⠀⢰⠋⠀⢸⣿⡏⣿⠀⣧⠹⡇⢸⣷⣶⣶⣦⠀⠀⠁⠀⠈⠉⠉⠀⢻⡆⡿⠳⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣰⠃⠀⠀⢸⣿⠀⣿⣧⡹⣆⢻⡀⢿⠊⠻⠿⠀⠀⠀⠀⠀⡀⠀⠀⢠⣧⣧⠀⠙⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⣠⣄⠀⠀⠀",
+    "⠀⠀⠀⢀⡜⠁⠀⠀⠀⠈⣇⠸⠁⡇⠳⣝⢿⣷⡌⢿⣄⠀⠀⠸⢶⣶⣿⣿⠀⢠⢻⡿⠷⢽⣦⣄⡀⠀⠀⠀⠀⢀⣿⣾⠟⠋⠉⠉⠲⡀",
+    "⠀⠀⣠⠋⠀⠀⠀⠀⠀⠀⠏⠀⣸⠀⠀⠈⠓⢿⡝⣄⢻⣟⢤⡤⢄⣙⡷⢏⡴⠃⢸⣀⠀⠀⠀⠀⠀⠀⠀⠀⢘⣳⣿⣣⣴⠶⣤⣲⣄⠀",
+    "⢀⡜⠃⠀⠀⠀⣀⣀⡀⠀⠀⢀⠏⠀⠀⠀⠀⠀⠙⢮⣻⡬⠛⠓⠚⠷⣿⡋⠉⠉⣿⣿⣷⡔⠒⠛⠓⢦⡀⠀⠈⣯⣿⡝⢿⣷⣼⣻⣎⣷",
+    "⠎⠀⠀⠀⠀⠺⡉⠉⠙⠒⢤⣜⣀⣀⣠⣤⣤⣤⣤⣴⣿⣶⣄⠀⠀⠀⠈⢻⡒⠀⣿⣣⣘⣿⣆⠀⠀⠀⠹⣄⢸⣿⣿⣷⡈⢻⣿⣷⡿⣅",
+    "⠀⠀⠀⠀⠀⠀⡉⠓⣢⢤⣄⠀⠈⠉⠉⠙⢿⣿⣿⣿⣿⣯⣿⣷⠀⠀⠀⠀⢳⢦⠉⠉⠳⣌⠛⣝⠲⢤⡀⠈⣾⣿⣿⣿⣿⣦⡙⣿⣷⣿",
+    "⠀⠀⠀⣠⠇⠟⢀⣾⣵⣿⠿⠀⠀⠀⠀⠀⠘⣮⠹⣿⣿⣿⣿⣿⣀⡀⠀⠀⠈⡇⠀⠀⠀⠈⢧⡀⠱⣄⠈⠓⢾⣿⣿⣿⣿⣿⣿⣿⣿⣼",
+    "⠀⢀⣴⠏⠆⢀⣾⣿⡿⠃⠀⢈⠉⠓⠒⠒⠉⠈⢳⡙⣿⣿⡟⠋⠉⠻⣧⣀⠀⣿⠀⠀⠀⠀⠀⠱⡄⠈⠳⣄⠀⢘⣿⣿⣿⣿⣿⣟⣧",
+    "⢀⣿⠏⠀⣠⡾⠛⠉⣀⣀⠀⠀⠑⢜⠢⢤⣀⠀⢈⣧⢻⡟⢧⠀⠀⠀⠀⠹⣆⣿⣷⣄⠀⠀⠀⠀⠹⣦⠀⠘⢦⠘⣿⣿⣿⣿⣿⣿⣿⢿",
+    "⠈⠏⢠⡞⠁⣀⣴⣾⣿⡟⠁⣀⣀⠀⢣⠤⣌⣳⣾⣿⢸⠁⠀⠳⡀⠀⠀⢠⣿⠿⣿⡛⠓⠀⠀⠀⣠⣿⡆⠀⠸⣿⣿⣿⣿⣿⣿⣿⣿⣟",
+    "⠀⠀⠘⠲⠚⢉⣼⡿⠋⢀⣴⣿⣿⡇⠀⣧⣄⠈⠙⠻⣿⠀⠀⠀⠙⢶⣶⣿⣿⡄⠈⠛⢦⣄⣀⠘⠛⣻⡇⠀⢠⡏⣿⣿⣿⣿⣿⣿⣿⣿",
+    "⠀⠀⠀⠀⣰⡟⠹⠁⣠⣾⣁⠘⣿⡀⠀⣿⣿⣿⣷⣦⣾⠀⠀⠀⠀⠀⠙⣏⠿⠹⢦⡀⠀⠀⢀⣴⠾⠉⡇⠀⠸⡇⠈⠹⣿⣿⣿⣿⣿⣿",
+    "⠀⠀⠀⣰⡿⠀⠈⠈⠳⢾⣻⡿⣿⣷⣾⣿⡿⢿⣫⠝⠁⠀⠀⠀⠀⠀⠀⠈⢮⠣⡄⠻⠶⣾⡿⠋⣰⣾⡇⠀⠀⣷⡄⠀⠀⠙⠿⣿⣿⣫",
+    "⠀⠀⢠⣿⠇⠀⠀⠀⠀⠀⠀⠉⠛⠛⠛⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢳⣄⠀⠀⠉⢠⣾⣟⣿⠃⠀⢀⣿⠇⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢈⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⣿⠗⠀⣠⣿⡿⢁⡿⠀⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_5[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣶⣶⣤⡤⠤⠶⠶⠦⠤⣄⣿⢿⣷⢦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠟⠋⠻⠄⣀⠀⠀⠀⠴⢮⠑⢦⣿⣎⠻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⢡⠞⠀⡘⠀⣿⣷⣄⠀⠀⠈⢷⡀⠻⣿⣆⢸⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡏⢀⠏⡀⢠⢇⠀⢻⠹⣿⣷⠄⣆⠘⣿⣶⣿⡉⡇⢧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠘⡞⡾⡇⡿⠼⢆⠸⡞⣹⡾⣧⡹⡄⢻⣻⣿⡇⢸⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⢰⣧⠀⠋⣷⢶⣮⠓⣿⡅⢿⣿⣷⡘⠘⣿⡿⠁⠀⢇⢻⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣾⣿⣆⠈⢿⡾⣿⡆⠈⠉⠀⠉⠷⡿⡄⣿⡇⠀⢰⡼⡌⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣿⠈⠢⣸⣿⣆⠁⠀⠔⠂⢀⣼⣼⣿⣿⣧⠀⠸⡙⣵⢸⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠃⡀⠀⢸⢿⣿⣿⣶⣾⡯⠗⣿⡾⣥⠉⢻⡀⠀⢇⠙⣇⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡃⢰⠁⠀⡟⠈⣻⢯⣽⣿⣧⣴⠟⣤⡘⡇⠘⡇⠀⠘⡄⠸⡘⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡷⢁⠇⠀⢸⠃⢰⣯⢊⠏⣷⣾⣽⡇⠉⠹⡇⠀⢷⠀⠀⢱⠀⠱⠘⣧⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⠀⡞⠀⠀⡟⣴⣏⣧⠎⢀⠁⢀⣸⣧⣤⣤⣧⠀⢸⠀⠀⠀⢣⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣼⠋⠀⡘⠀⠀⢸⡿⣿⢿⠏⠀⢸⠉⣳⣴⡟⢻⣿⣿⡆⠘⡇⠀⠀⠈⣄⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⡼⠁⠀⣰⠁⠀⢀⡾⡛⢁⣮⡄⡰⣿⠘⠳⡿⡧⠿⠿⣿⣧⠀⡇⠀⠀⠀⠘⣆⠀⠀⠸⣧⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢀⡞⠀⠀⣰⠃⠀⢠⢿⡴⠓⡟⠛⠁⠀⣷⡗⢤⡸⡇⢀⣠⣿⣿⣆⢃⠀⠀⠀⠀⠈⢆⠀⠀⠹⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢠⡟⠁⠀⣰⠃⠀⣴⣥⣾⣧⡾⡇⠀⢀⡼⣷⠿⢀⣽⡇⠈⡟⠏⢿⣿⣿⠀⠀⠀⠀⠀⠘⡀⠀⠀⢹⡀⠀⠀⠀",
+    "⠀⠀⠀⢀⡾⠀⠀⢠⠃⢀⣾⣿⣿⣿⡿⢡⣿⣠⣾⠉⠻⣷⣿⣿⡇⠌⢹⠸⣘⣿⣿⣷⡄⠀⠀⠀⠀⢱⠀⠀⠈⣷⠀⠀⠀",
+    "⠀⠀⠀⡼⠁⠀⠀⡞⡰⠋⠀⠈⣷⣽⡳⢿⣷⣻⣿⠀⣀⣿⡿⣿⡧⠀⠘⡇⢿⢟⣿⣿⣿⡦⠀⠀⠀⠀⢧⠀⣆⠸⡇⠀⠀",
+    "⠀⠀⣸⠁⢀⠀⡸⢸⣥⣀⢀⣼⠟⣿⡏⠙⠒⢲⠽⠭⢵⡞⠊⠉⣿⠀⢀⣼⡈⢾⣿⣿⡿⠁⠀⠱⡀⠀⠘⡆⢸⣆⢻⡀⠀",
+    "⠀⢠⠇⢀⡎⢠⠃⠀⠈⢙⣿⣿⣿⣿⣧⣀⣀⣼⠀⠀⠀⣧⣤⣶⣿⣐⣿⣿⣷⣾⣿⢿⡄⠀⠀⡇⢳⠀⠀⢣⠀⣏⢎⡇⠀",
+    "⠀⠸⢀⣾⠁⡜⠀⠀⠀⠘⠛⡏⠀⢹⢿⡿⣿⡇⠀⠀⠀⢸⡍⣹⢿⣿⡈⠹⠿⠛⠋⠈⡇⠀⡄⠀⠀⠀⠀⠘⠀⠹⡜⣷⠀",
+    "⠀⡇⣜⡇⠀⠃⠀⠀⠀⠀⢀⠁⠀⣾⣾⣿⣿⠇⠀⠀⠀⠈⣧⠙⠿⣿⣧⡀⠀⠀⠀⠀⡇⠀⢇⠀⠀⠀⠀⠀⠀⠰⢇⢸⠀",
+    "⠀⡗⢹⠀⠀⠀⠀⠀⠀⠀⢸⠀⢠⡏⠀⣏⣿⠀⠀⠀⠀⠀⢹⣤⠀⢻⣿⣷⡀⠀⠀⠀⢳⠀⢸⠀⠀⠀⠀⠀⠀⠀⢸⠘⡇",
+    "⢰⡇⣼⠀⠀⠀⠀⠀⠀⠀⣸⠀⡾⡀⢸⣿⣿⡀⠀⠀⠀⠀⠀⣿⠀⠈⢿⣿⣷⡄⠀⠀⢸⠀⠀⡆⠀⠀⠀⠀⠀⠀⣼⡀⡇",
+    "⠘⡇⣿⡄⠀⠀⠀⠀⠀⠀⡏⢠⡇⠁⢸⣿⣿⡇⠀⠀⠀⠀⠀⢹⡇⠀⠘⣧⠻⣿⡄⠀⢸⠀⢰⡇⠀⠀⠀⠀⠀⢀⡟⡇⡇",
+    "⠀⡇⡇⣧⠀⡄⠀⠀⠀⠀⡇⢸⠱⠀⢸⠐⣿⡇⠀⠀⠀⠀⠀⠈⡏⠀⠀⢹⡀⢹⣷⡀⡟⠀⡞⡇⠀⠀⢀⠆⠀⡼⠀⣇⡇",
+    "⠀⢃⡇⠸⡆⢱⠀⠀⠀⠀⡇⣸⠀⠀⣾⡆⢸⣧⠀⠀⠀⠀⠀⠀⢷⡆⠀⠈⣿⠀⣿⣷⡇⣰⠁⡇⠀⣦⠎⠀⣸⠃⢰⣿⠃",
+    "⠀⢸⣿⠀⠹⣆⠣⡀⠀⠀⢻⢿⠀⠀⣿⣤⣼⣿⡄⠀⠀⠀⠀⠀⢸⣧⣤⣴⣿⣡⣾⣿⣷⠁⠀⡇⢠⠏⢀⡼⠃⠀⢸⡟⠀",
+    "⠀⠀⢻⡆⠀⠈⠻⣷⣄⠀⢸⢼⣾⣿⠿⠿⠛⠻⣿⡄⠀⠀⠀⠀⠘⣿⣿⣿⡿⠿⢿⣿⣿⠀⢰⠇⢀⣴⠟⠁⠀⠀⣾⠃⠀",
+    "⠀⠀⠈⠁⠀⠀⠀⠈⠙⠷⣤⣿⣿⣧⣀⣀⠀⠀⢻⣿⠀⠀⠀⠀⢸⠁⣨⡿⠀⢀⣸⣿⠏⠀⣾⡶⠋⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⢿⣾⣷⣴⣿⡿⠀⠀⠀⠀⢺⣿⣯⣀⣶⣾⡿⠋⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠀⠀⠀⠀⠀⠀⠙⠛⠛⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_6[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠄⠋⠑⣦⡀⠀⠀⣠⠴⢋⠁⠀⠀⠀⢀⡴⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⢦⡀⠀⢀⣠⠤⠒⠉⠉",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠢⠐⠒⠀⠀⠀⠀⠀⠙⣦⠞⢁⠔⠉⠀⠀⠀⢰⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣞⠉⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⠃⠀⠀⠀⣠⠞⠁⠀⠋⠀⢀⡴⠀⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢢⡀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡷⢀⡾⢁⡞⠁⠀⣠⠞⠁⠔⠋⠀⠀⡜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠱⡀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣇⣸⡵⠋⠀⣠⠞⠁⠀⠀⡄⠀⠀⢀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⡄⠀⣀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡼⠋⣨⠏⢀⣤⠔⠁⠀⠀⢀⡼⠁⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠰⣿",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣇⡼⠉⢀⠞⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⠀⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠟⠁⢠⡟⠀⠀⠀⠀⠀⡘⠁⠀⠀⠀⠐⣿⠀⠀⠀⠀⠀⠀⠀⢀⡿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⣠⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⡀⠀⠀⠀⠀⠀⠀⢸⠁⢻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢀⡟⠀⣰⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠏⢸⡇⠀⠀⠀⠀⠀⠀⢸⠀⠀⢻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⡼⠀⢠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣻⠋⠀⠀⡇⠀⠀⠀⠀⠀⠀⣸⠀⢦⠀⠹⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰",
+    "⠀⠀⠀⠀⠀⠀⡸⠁⢠⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠷⠶⠦⣤⡇⠀⠀⠀⠀⠀⠀⣿⠀⠈⢣⠀⠘⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸",
+    "⠀⠀⠀⠀⠀⣰⠃⢀⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠋⠀⠀⠀⠀⣇⠀⡇⠀⠀⠀⠀⡟⠀⠀⠀⠑⠄⠈⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢰⠃⢀⣼⠃⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡏⠀⠀⠀⠀⠀⢹⣰⣿⡄⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⣀⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠃⠀⠚⠁⢠⡌⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⣷⣿⣷⣶⣦⡀⢸⣏⡏⢷⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠁⠀⠙⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⡾⠀⢨⡇⠀⠀⠀⠀⠀⠀⠀⢰⣿⠋⢡⠉⢻⣿⣿⣿⣦⣹⡇⠸⣆⠀⠀⣇⠀⠀⠀⠀⠀⠀⢀⣠⠄⠈⢳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢰⠇⣀⣿⡇⣄⠀⠀⠀⠀⠀⢸⣿⡟⠀⣼⣿⣿⠟⢿⣿⣿⣿⠇⠀⢻⣆⠀⢸⠀⠀⠀⠀⠀⠶⣉⣠⣶⣾⣿⣿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣿⠀⣿⡿⠁⢿⠀⠀⠀⠀⠀⣼⡟⢷⠀⢻⠻⣇⡀⣸⣿⡿⠁⠀⠀⠀⢻⡀⢸⠀⠀⠀⠀⠀⣶⠿⠿⣿⣿⣿⣿⣿⡿⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⡟⠀⣿⠇⠀⢸⡆⠀⠀⠀⠀⢻⣿⠀⠃⠘⢧⣉⣋⣉⡿⠃⠀⠀⠀⠀⠀⠻⣼⡀⠀⠀⠀⠀⠩⣦⣴⡿⠛⠛⣿⣽⡿⠙⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠁⢸⡟⠀⠰⠸⣇⠀⠀⠀⠀⣾⣿⡄⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠙⠧⠀⠀⠀⠀⠀⣿⢿⣷⣤⣠⡿⣻⠇⠀⣼⢿⣦⣴⡆⠀⠀⠀⠀⠀⠰⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠸⠃⠀⠀⡆⢻⠀⠀⠀⢰⡏⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⠜⠶⣬⣭⣥⡴⠋⠠⠞⠁⣰⣿⣿⣷⡀⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢱⡸⣇⠀⠀⣸⠁⢸⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡿⠉⣿⡿⣧⠀⠀⠀⠀⣽⡅⠀⢇⡀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠇⢻⡇⢀⡏⠀⢸⡏⢻⣄⠀⠀⠀⠀⠀⠀⢠⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⠁⠀⢸⣧⣿⡄⠀⠀⠀⡟⡇⠀⣾⠁⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢷⣾⡇⠀⢸⡇⠀⠙⢷⣄⠀⠀⠀⠀⠈⣏⠉⠉⠓⠒⠤⣤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⠃⠀⠀⣰⣿⣿⣷⡀⠀⢰⠇⡇⢠⡇⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⡀⢀⣸⣟⣿⡀⢸⡇⠀⠀⠀⠉⠳⣦⡀⠀⠀⠈⠳⢤⣤⣤⡴⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⠇⠀⠀⣼⣟⢻⣿⣿⣇⠀⢸⠀⡇⣾⠃⠀⠀",
+    "⠀⠀⠀⢀⣤⠖⠋⠉⠉⠉⠉⠉⠉⠁⠈⠙⢷⣸⣷⠀⠀⢀⣠⡶⠋⠉⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣠⣴⡾⠻⣿⣿⣿⡿⠀⢠⠾⠛⠛⠛⣿⣿⣿⡀⡏⠀⣷⠏⠀⠀⠀",
+    "⠀⠀⢠⠏⢁⠏⠀⠀⣰⡇⠀⠀⢠⡇⠀⠀⡄⠈⢻⣦⣤⣾⠁⠀⠀⠀⠈⠿⣝⠶⣄⣀⠤⠤⠖⣲⠟⠋⠁⠀⠈⣻⢷⣤⣿⣿⣿⠃⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠏⠀⠀⠀⠀",
+    "⠀⠀⡎⢀⣼⠀⠀⢠⡻⠀⠀⢀⣿⠀⠀⢰⠃⠀⢸⠃⠀⢸⡆⠀⠀⠀⠀⠀⠈⠳⣄⠀⣠⠴⠛⠁⠀⠀⠀⠀⢹⠇⡜⠛⠿⠿⣯⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢸⠃⣼⡇⠀⠀⣾⡇⠀⠀⢸⠃⠀⠀⡎⠀⠀⣎⠀⢠⡟⠃⠀⠀⠀⠀⠀⠀⠀⢿⠟⠁⠀⠀⠀⠀⠀⠀⠀⡜⢹⡇⠀⠀⠀⡾⠃⠀⠈⠉⠙⠻⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⣯⣀⣀⣼⡟⠀⠀⣠⠏⠀⠀⣰⠃⠀⣸⠋⣷⣿⠀⠐⠀⠀⠀⠀⠀⠀⢀⣨⣤⡀⠀⠀⠀⣰⠚⠀⠀⠁⠀⣷⠀⠀⠈⠁⠀⠀⠀⠀⠀⠀⠀⠉⢻⣿⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠸⢤⣠⢾⡁⠀⣠⠴⣏⣄⡀⠀⢀⡿⠃⠀⢀⠀⠀⠀⠀⢀⡾⠋⠉⠉⠛⣆⠀⢠⡏⠀⠀⠀⠀⠀⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣧⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠉⠉⠁⠀⠀⠀⠉⠛⣻⠀⠀⠀⠈⠀⢀⣀⠤⢻⠀⠀⠀⠀⠀⣿⡆⠘⠇⠀⠀⠀⠀⠀⠀⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀",
+    "⢀⠀⢀⠀⣀⣀⣀⣀⣀⣼⣀⡀⠀⢠⣀⣀⡀⣈⡅⠀⠀⠀⠀⠀⠈⠀⠀⠈⢷⡀⠀⠀⣠⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⡼⠷⠤⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_7[] = {
+    "⠀⠀⠀⠀⠀⢀⡞⡼⠋⠀⠀⣤⣦⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⢿⡟⢟⢻⣍⠉⠙⣿⣿⣿⣶⣿⣿⣿⣿",
+    "⠀⠀⠀⠀⢀⡞⣼⠃⠀⢀⣾⣿⣿⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢤⡙⣷⡄⠈⢣⡻⣿⣿⣿⣿⣿",
+    "⠀⠀⠀⢀⡞⣸⠏⠀⢠⣿⣿⣿⣿⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠈⠛⣿⣶⡀⢳⡝⣿⣿⣿⣿",
+    "⠀⢠⠆⡾⢰⡏⠀⣰⣿⣿⣿⣿⣿⠁⠀⠀⠀⢀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⣀⠀⠀⠈⢿⣷⣼⣿⡄⣿⣿⣿",
+    "⠀⠘⢸⣥⣿⠁⣰⣿⣿⣿⣿⣿⡟⢰⠀⠀⢀⡞⠀⠀⠀⢀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⢿⣷⣄⣠⣾⡟⠙⠻⣿⠹⣿⣷",
+    "⠀⠁⠈⣿⣧⣴⣿⣿⣿⣿⣿⣿⠇⠈⠀⠀⢰⠃⠀⠀⠀⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⣹⣿⣿⣯⣧⡄⠀⠈⢧⠹⣿",
+    "⠀⠀⠀⠉⠈⠻⣿⣿⡟⢻⣿⣿⠀⠀⠀⡄⡎⠀⠀⠀⣼⡟⢷⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡯⣾⠿⠁⠙⢿⣿⡇⠀⠀⠸⣷⡈",
+    "⠀⠀⠀⠀⠀⢠⣿⣿⡇⠸⣿⡏⠀⠀⠀⣇⠃⠀⢠⣾⣿⠃⣿⠠⡄⠀⠀⠀⠀⠀⠀⠀⠀⣠⠖⢸⠁⡇⠀⠀⠀⠁⠀⡇⠀⠀⠀⣿⠀",
+    "⢠⠀⠀⠀⠀⢸⣿⣿⣿⡀⢿⡇⠀⠀⠀⣿⣀⡴⢃⠟⠁⠀⢿⡇⢧⣀⠀⠀⠀⠀⠀⠀⢠⠗⢲⣿⢲⡗⠀⠀⠀⠀⠀⠐⠀⠈⢷⣿⠀",
+    "⡈⠀⠀⠀⠀⣼⣿⣿⡿⢃⢸⡇⡇⠀⠀⢿⠛⠠⠋⠀⠀⠀⠘⣿⣌⢿⠀⠀⠀⡆⠀⢀⡏⢀⡞⣹⡏⢳⠀⠀⠀⠀⠀⠘⠀⢀⠸⠟⠂",
+    "⣿⠀⠀⠀⠀⣿⣿⣿⣿⢸⡆⠃⣇⠀⠀⠸⡤⠷⠶⢶⣴⣶⣄⠈⠛⣎⣇⠀⠀⡇⢀⣾⢁⠞⠀⡿⠁⢹⠀⠀⠀⠀⠀⠀⠀⢸⣦⡀⠀",
+    "⣿⠀⠀⠀⢰⣿⣿⣿⣿⠀⡇⣌⢻⡀⠀⠀⢱⡀⠀⠀⠈⠙⠻⠀⠀⠈⠙⢶⡀⢳⠎⢘⣸⣶⣾⣧⣄⠀⡇⣦⠀⠀⠀⡀⠀⠀⢿⣧⠀",
+    "⣿⠀⠀⠀⢸⣿⡿⣿⣿⡇⢱⠘⣤⣱⡀⠀⠈⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠻⣴⣿⣿⣿⣿⡙⢿⣷⣇⢸⠀⠀⠀⡇⠀⠇⢸⣿⡄",
+    "⣿⠀⠀⠀⢸⣿⡧⣿⣿⣧⠸⡀⢻⡍⠱⡄⠀⠈⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢏⣙⡿⠋⠀⢈⣽⣿⣿⡆⠀⠀⣿⠀⠀⠀⡇⠇",
+    "⢹⡀⠀⠀⢸⣿⡇⢸⡿⣿⡄⡇⠈⢣⠀⠙⡄⠐⡀⠀⠤⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⢠⣾⣟⣿⣿⣹⣄⢠⡿⠀⠀⠀⠀⠀",
+    "⢸⡇⠀⠀⣾⠟⠃⢸⡇⢻⣿⡇⠀⢀⡡⠖⣻⣆⠘⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⢁⣾⣿⠿⠋⣹⢿⣄⠀⠀⠀⠀⠀",
+    "⢸⡇⠀⠀⡍⠀⠀⢸⡇⠈⢿⡷⠞⠁⢀⡼⠋⣿⣷⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⡟⢻⣿⡿⠁⣠⣾⡷⠾⢿⡇⠀⠀⠀⠀",
+    "⠘⣷⠀⠀⠀⠀⠀⢸⡷⣶⠏⠀⢀⡴⠋⠀⢀⣿⣿⡀⠙⠢⣀⠀⠀⢀⣀⣀⣤⣴⣶⣿⣿⣿⠃⢰⡟⠁⣰⠟⠁⣠⣴⣿⠀⠀⠀⠀⠀",
+    "⠀⣿⡀⠀⠀⣠⢞⣥⡾⠁⢀⡴⠋⠀⠀⢀⣾⢡⣿⡷⣤⣀⣈⣉⣉⣠⣿⡿⢋⣭⠥⣶⠞⠁⠠⠫⠤⢼⣁⣠⣾⣟⣿⣿⡆⠀⠀⠀⠀",
+    "⠀⣿⡇⠀⢸⡏⢿⡿⠁⠀⠊⠀⠀⠀⠀⡾⢁⣾⠟⠙⠛⠿⠿⠿⢿⣿⢏⡴⠋⢀⣴⠷⠾⠒⡑⠒⠒⠤⣈⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀",
+    "⠀⢹⣿⠀⠸⡇⢸⣉⠓⠲⢤⣄⣀⣀⡤⠖⠋⠀⠀⠀⠀⠀⠀⣼⣿⢋⡞⣡⣴⡟⣹⠀⠀⠀⠀⢉⡶⠄⠈⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀",
+    "⠀⠸⣿⣆⢀⡏⠒⠬⣍⣓⠲⢬⣿⣦⣄⠀⠀⠀⠀⣀⠀⠀⣸⣿⣇⣾⣿⣿⣿⡇⡿⣄⠀⣠⠔⠉⠀⠀⣰⣿⣿⠋⣩⣿⡿⣷⠀⠀⠀",
+    "⠀⠀⣿⣿⣸⣷⡄⠀⠀⢠⣉⠓⢬⡙⢿⣷⣄⠀⠀⠀⠙⢲⣿⣿⣿⣿⣿⣿⣿⢠⡇⠈⡷⢤⣀⡀⢀⣰⡿⣿⣿⣿⠋⠀⡇⢿⠀⠀⠀",
+    "⠀⠀⢸⣿⠏⡾⣿⣦⣄⣀⠙⢿⣶⣽⣦⣝⢿⣷⡀⠀⢀⣿⢿⣿⣿⣿⣿⡿⢿⣾⠗⢀⡇⠀⠀⠉⠉⡝⠀⣿⣿⣿⠀⠀⡇⢸⠀⠀⠀",
+    "⠀⠀⠈⣿⢰⡿⠋⠙⠻⢿⣿⣶⣿⣿⣿⣿⣦⣹⣷⡄⣸⣿⣿⣿⣿⣿⠋⣰⣿⣿⣇⣸⠀⠀⠀⠀⠀⡇⢸⣿⣿⣿⣆⠀⠃⠈⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_8[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣤⣤⡤⢤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⡾⠋⢲⡄⠀⠀⠀⠁⠀⠀⠀⠉⠳⣮⠷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⣤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⠋⠀⠀⠀⠙⣆⠀⢀⣠⣴⣶⣿⣿⣿⣿⣷⣿⣿⣿⡗⠲⠶⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠹⡄⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠁⠀⠀⠀⠀⠀⣸⣿⡿⠟⠛⣩⡴⠋⠁⠈⣻⠛⢧⡉⠛⠷⣄⡀⠉⠛⢦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢱⠀⠀⠀⠀⠀⠀⣠⣾⡟⠛⠦⣤⡀⠀⣠⣾⠟⠋⠀⢠⡾⠋⣀⠀⠀⡼⠁⠀⡆⠹⡄⠀⠈⠳⣅⠀⡀⠙⢧⡀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣤⣶⠆⠀⠀⠀⠀",
+    "⠀⠀⠘⡄⠀⠀⠀⠀⡼⠋⡏⠀⠀⠀⠀⠉⣵⠟⠁⠀⠀⣴⠏⠀⣰⠁⠀⢰⠃⠀⠀⡇⠀⢻⡄⠀⠀⠙⣦⠈⠳⣄⠹⣄⠀⠀⠀⣠⣴⣾⣿⣿⣿⣤⣄⠀⠀⠀⠀",
+    "⠀⠀⠀⣷⠀⠀⠀⢰⠇⢀⣇⠀⠀⠀⢀⡼⠋⠀⣴⠖⠛⣱⠀⣰⠃⠀⡄⢸⠀⢠⠀⡇⠀⠘⣿⡀⠀⠀⠘⣧⠀⠈⢳⣜⣧⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⠄⠀⠀⠀",
+    "⠀⠀⠀⢻⡀⠀⠀⢸⠀⣸⠻⣆⢀⣴⡯⠀⢀⡞⠁⠀⣰⠃⣰⠃⠀⣼⠀⡏⠀⣸⠀⡇⠀⠀⣧⠷⡄⠀⠀⡘⣇⠀⢦⣝⣿⣿⣿⣿⣿⠟⠏⠀⠘⢿⣀⠀⠀⠀",
+    "⠀⠀⠀⢸⡇⠀⠀⡟⢠⡏⠀⣹⣿⡞⠁⢀⡞⠀⠀⣴⠇⣼⡟⠀⢠⠃⢠⣇⠀⣷⠀⡇⠀⠀⣿⠀⢹⠀⠀⠘⡘⣦⠀⠉⢻⣿⣿⣿⣿⣿⠀⠀⠀⠀⣨⣟⠁⠀⠀",
+    "⠀⠀⠀⣼⣿⠀⢰⡇⣼⠁⢸⣿⣿⠃⢀⣾⠀⠀⡼⢹⢱⠃⡇⠀⡼⠀⢸⣿⠀⣿⣄⡇⠀⠀⣿⠀⠈⡇⠀⠀⢣⠙⡆⠀⠘⣿⣿⣿⣿⣷⣷⠒⠚⠋⠁⣹⣷⠀⠀",
+    "⠀⠀⠀⣿⠙⡆⢸⣧⡏⠀⣿⡟⡟⠀⡾⡋⠀⡾⠓⢺⡟⢴⣧⠀⡇⠀⠸⣿⣆⢻⠻⣷⠀⠀⣿⠀⢰⢹⡄⠀⠘⡆⢹⡀⢀⣿⡿⣿⣿⣿⣷⡲⢶⣶⣖⠛⠋⠀⠀",
+    "⠀⠀⠀⣿⠀⣧⢸⣿⠀⢸⣿⣴⠇⡼⠀⣇⡾⠁⠀⢸⡇⠀⡇⢀⡇⠀⠀⣿⡟⢮⣦⣸⣄⠀⣿⠀⢸⡘⣧⠀⠀⣷⠀⣷⠈⣿⣀⣨⡏⠙⢿⠷⣿⣿⡿⠷⣆⠀⠀",
+    "⠀⠀⠀⡿⠀⣿⢸⡏⠀⣼⣿⣿⢀⡇⠀⣿⣷⣿⣶⣾⣗⠀⢹⣼⡇⠀⠀⢸⡇⠈⠻⣝⣿⠻⢾⡄⠈⡇⢻⡀⠀⢻⡄⢹⣾⡏⠙⠿⠟⠻⣿⡷⢽⣿⣦⣀⣼⣷⠄",
+    "⠀⠀⢸⡇⠀⠸⡿⠁⢀⣿⠁⡿⣾⡇⢘⣿⡟⣿⣟⣿⡟⢷⡈⣿⣿⡀⠀⠈⡇⠀⠀⠈⠻⣦⣼⣏⠹⡇⠀⣧⠀⢸⣇⠈⣿⠷⣾⣿⣆⣤⣯⡀⣀⣿⣇⡼⠟⠉⠀",
+    "⠀⠀⢸⠁⠀⠀⡇⠀⢸⣿⠀⣿⣿⣷⡀⡇⠀⣿⢿⡿⠇⠈⠁⠈⢯⣷⡄⠀⣟⣭⣷⣶⣶⣮⣿⡸⣆⣳⠀⣿⠀⠘⣿⠀⣿⣄⣼⡏⠀⣹⣿⣭⡿⠿⠋⠀⠀⠀⠀",
+    "⠀⠀⣿⠀⠀⠀⡇⠀⢸⣿⠀⠸⣿⣯⣷⣳⡀⠘⠛⠋⠀⠀⠀⠀⠀⠀⠙⢦⣇⣾⣿⣿⣿⡎⢿⣗⣹⣷⠀⣿⡇⢠⣿⣤⡇⠠⡿⣿⠋⢹⠂⣿⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⡏⠀⠀⠀⡇⠀⢸⣿⠀⠀⠻⣿⣿⠹⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢧⡻⠟⠻⠇⢈⡟⢻⣷⠀⢁⡇⣼⢿⣿⠂⢰⠇⡟⠀⣸⡆⢸⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢰⡇⠀⠀⠀⡇⠀⠸⣿⠀⠀⠀⠉⣿⣆⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠛⠻⠭⠌⠋⢠⡿⡇⢠⣼⣿⣿⣸⡟⠀⣸⠀⠇⣰⠏⣷⣾⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢸⡇⠀⠀⠀⡇⠀⠀⣿⠀⠀⠀⢀⡇⠘⢦⡀⠀⠀⠠⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣼⡇⢰⣿⣿⡿⢻⠀⢀⡇⢠⡼⠃⠀⣿⣿⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⣸⠁⠀⠀⣸⡷⠿⢦⣽⣀⠀⠀⢸⠁⠀⠀⠹⣦⡀⠀⠀⠉⠉⠉⠉⠁⠀⠀⠀⠀⠀⢀⣠⠾⣿⣿⣠⠟⢡⡟⠀⢸⠀⠘⢀⡾⠁⠀⠀⢿⡏⠀⠀⠀⠀⠀⠀⠀",
+    "⣤⡇⠀⠀⠀⣿⠲⣆⠀⠀⠉⢛⣶⣯⣤⣤⣠⣤⣼⢷⣦⡀⠀⠀⠀⠀⠀⢀⣀⣤⡤⠶⠋⠁⠀⣸⠟⠁⠀⠋⠀⠀⢸⣦⣷⠞⡇⠀⠀⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⣿⠃⠀⠀⢀⣿⡄⢿⠉⢳⣶⢿⣿⣿⣿⣿⣿⡿⠃⢸⣿⠙⠓⠒⠒⠊⠉⢉⡽⢿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣿⡎⢀⡇⠀⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⣿⠀⠀⠀⢸⠙⣧⠘⣿⠭⢥⣸⣿⣿⣿⣿⣿⠃⠀⠀⠻⣧⡀⠀⣀⡤⠞⠋⠀⢸⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⢰⠀⠀⠀⠀⢿⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⡏⠀⠀⠀⡿⡄⡸⡖⢿⣷⣶⣾⣿⣿⣿⣿⡇⠀⠀⠀⣀⣈⣻⡻⠝⠒⠁⠀⠀⣸⣿⣿⣷⣦⣄⡀⠀⠀⠀⠀⠀⠀⢸⡟⠀⠈⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠁⠀⠀⣸⠃⠙⣧⠸⡄⠹⣍⠉⣿⠛⡿⢿⣀⡤⣖⣋⣩⡿⢻⠻⡄⠀⠀⠀⢰⣿⣿⣿⣿⡿⢹⡏⠉⠙⠒⠢⣄⣀⣸⠃⠀⠀⠀⠀⠀⠀⢻⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢠⠏⠀⠀⣹⡀⠙⢦⡉⣿⣿⡾⠁⠀⠀⣀⠝⣿⠋⣀⣈⢧⡹⡖⠀⢀⣿⣿⣿⣿⡿⠃⢰⡷⢤⣀⣀⠀⠀⠙⢿⡆⠀⠀⠀⠀⠀⢰⢸⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢠⡟⠀⢀⠶⢹⠇⢠⡎⠁⣿⣽⠃⠀⠀⠈⠀⠀⢸⣿⡿⠟⠉⠉⠙⢦⠞⣸⣿⡿⠿⣭⣉⠛⢶⡤⣽⣎⠙⡗⠦⣈⣧⠀⠀⠀⠀⠀⢸⡘⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⢀⡞⢀⡴⠃⠀⢸⠀⡞⠀⢸⣟⣿⣄⣀⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠀⠀⠀⡟⢷⠀⠀⡘⡫⣳⣄⢹⡄⣸⠛⢻⢦⣼⣿⡀⠀⡇⠀⠀⠈⣷⢻⠀⠀⠀⠀⠀⠀⠀",
+    "⣾⠐⠋⠀⠀⠀⣾⢸⠁⠀⢸⣽⠁⠀⠩⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣵⣷⣄⣠⣭⠀⢈⣿⣾⣇⡏⠉⢻⠀⠈⢿⠀⠀⡇⠀⠀⠀⣿⡞⣇⠀⠀⠀⠀⠀⠀",
+    "⠋⠀⠀⠀⠀⢀⡇⠘⠀⠀⣿⡇⠀⣀⠀⠀⠊⢳⡀⠀⠀⣀⣀⣀⣀⡀⢰⣯⣸⡋⠁⠻⠟⠑⢿⡟⢻⡙⠀⠀⢸⠀⠀⠈⡇⠀⢹⠀⠀⠀⢸⣷⢻⡀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣾⠁⢰⠀⠀⣿⠁⢺⣿⡧⠀⠀⠐⠹⠞⠉⠁⠀⠀⠊⠉⣿⠻⣿⠿⢶⣿⡦⣴⣾⣧⠏⠀⠀⠀⢸⠐⠀⠀⢧⠀⢸⠀⠀⠀⠈⡟⣏⣇⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢠⣿⣀⡏⠀⠀⣹⡄⠀⠀⠀⠀⠀⠀⠀⠀⢠⣶⣶⠀⠀⢰⢧⣶⣷⣄⣤⣯⠀⣸⢿⡿⠖⣆⠀⠀⢸⠀⣀⡤⣼⠀⢸⡇⠀⠀⠀⢷⢹⣸⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣸⣿⡅⠀⠀⠀⠈⣳⣀⠀⠀⠀⠀⠀⠀⠀⠀⣉⡉⠀⢠⣇⣀⣽⡋⠈⢻⢟⡿⣡⠞⠀⠀⠈⠓⢲⠞⠋⣀⢴⡟⠀⠈⡇⠀⠀⠀⢸⣄⣯⣧⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_9[] = {
+    "⠀⠀⠀⠀⢰⣿⣿⣿⣿⡿⠁⠠⢀⣿⡙⣎⠁⠀⢀⠀⣯⠰⠀⡀⠰⢹⡋⢍⢿⣿⡹⢿⣏⢷⢹⠨⣁⠋⡙⢻⣿⣏⣏⠳⠄⠀⢹⠰⡁⢏⡿⣧⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣹⣯⣿⣿⣿⠃⡈⡴⢹⣇⠳⠈⢀⠐⠀⢂⡇⢂⠁⢀⠂⡏⠌⢆⠘⣷⢯⡹⣿⠞⡆⠆⠀⠈⠀⠁⠹⣞⡦⡁⢊⠀⠌⡱⠀⡈⢽⣛⡆⠀⠀⠀",
+    "⠀⠀⠀⠀⣼⣷⣞⣿⠇⡚⣼⠁⣿⢨⡑⠈⡀⠄⠡⣘⡇⢀⠂⠠⢸⠌⠀⠈⡀⠈⢿⡱⢿⣿⡸⡄⠀⠀⠀⠀⠀⠘⣷⠡⢀⠂⢦⠑⠠⠐⢸⣻⡇⠀⠀⠀",
+    "⠀⠀⠀⠀⣿⣿⢾⡟⢬⣱⡏⣴⣏⠖⡠⠁⠄⡈⢰⡱⡇⢀⠂⠡⡍⠀⠀⠀⠴⢄⣈⢿⡜⡿⣕⠲⠀⡀⡠⠔⠒⠉⠸⣗⠄⠂⢱⡘⠠⠁⢂⠿⣽⠀⠀⠀",
+    "⠀⠀⠀⠀⣿⣿⣻⢍⣶⡻⢼⣽⣎⠳⣔⡣⡔⢦⣏⡷⡇⠠⠈⣴⠃⠀⠀⠀⠀⠀⠀⠉⢷⡹⢻⡄⢣⠀⠀⢀⠤⣀⣦⣹⣞⡄⠘⡆⠡⠐⢈⠺⣝⠀⠀⠀",
+    "⠀⠀⠀⠀⣿⣿⡏⡼⣞⡏⣿⣿⡜⣣⢿⣱⢛⡾⣽⣻⡇⠠⢁⣿⣶⣶⣤⣄⡉⠳⡄⠀⠀⠙⡄⠹⡄⡄⠀⣱⡿⠟⠛⠻⣿⡶⡀⣏⠐⡀⣢⠸⣝⡆⠀⠀",
+    "⠀⠀⠀⠀⣿⣿⣱⣻⣽⡇⣿⣷⣙⡞⣧⣏⢯⣿⢷⣻⣧⠐⣸⠛⠉⠉⠉⠛⢿⣦⡀⠀⠀⠀⠀⠀⠙⡴⣰⣿⣶⣷⣦⡀⠘⣿⡄⡧⠐⢠⠙⡖⣭⡇⠀⠀",
+    "⠀⠀⠀⢠⣿⢧⢷⣛⡽⡇⣿⡧⡇⢽⣳⣞⣻⣾⢿⣻⣿⠀⣿⣾⣿⣿⣷⡄⠀⠙⠃⠀⠀⠀⠀⠀⠀⠘⢆⣿⣿⣿⣿⠇⠀⣿⣷⡗⠠⠘⠀⠈⠳⣇⠀⠀",
+    "⠀⠀⠀⢸⣿⢺⣟⡧⡗⣇⣿⣽⡇⢚⣷⣞⣯⣿⣟⣿⢿⣷⡿⣿⣿⣿⡿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠉⠛⠠⠀⢰⣿⣿⡕⢀⠃⠀⠀⠀⠙⠀⠀",
+    "⠀⠀⠀⢸⣯⣟⣿⣳⠇⡇⣿⣿⡇⢘⣷⣿⣿⣿⣻⣯⢿⢿⡇⠁⠉⠋⠁⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠐⠂⠈⢠⣿⣿⣏⠀⠆⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⣾⣿⡽⣾⣭⡇⣏⣿⣿⣷⠀⣿⣿⣿⣿⣿⣳⢿⠘⡏⠀⠀⠀⠂⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣷⠸⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠈⣾⢯⣷⣻⢖⡇⣾⣽⣿⠙⣧⢜⣿⣿⣿⣿⣯⢿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡟⣯⣟⣆⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⣟⡾⣭⣟⡞⡇⣽⣿⣿⠀⠹⡜⣿⣿⣿⣿⣿⣾⠟⠢⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⡀⠀⠀⠀⠀⣀⢾⣟⠧⡏⣿⢻⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⣯⢷⣟⢾⡹⡇⣾⢹⣯⠀⠀⠘⣽⣿⣿⣿⣷⡿⢦⡀⠐⣂⡀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠍⠘⠁⠀⠀⠠⢚⠀⢈⡾⣓⡇⢯⡚⡄⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢀⣯⡿⣏⣾⡱⡇⣿⠠⣿⠀⠀⠀⠈⢾⣿⣿⣿⣿⠈⠻⠿⣿⣿⣑⣆⠠⣀⣤⣶⣶⣶⣶⣶⣄⡀⠔⠁⠀⠀⡆⠠⣟⢸⠄⢳⡁⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢸⣷⡿⣏⢶⣹⢣⣿⠀⢿⠀⠀⠀⠀⠀⢻⣿⣿⣿⠀⠀⠀⢀⡝⠙⠻⣟⠿⢿⣿⣯⣿⣷⣿⠏⠁⠄⡀⠀⠀⣇⠀⢻⣏⠂⢸⡁⣇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⣸⣯⢿⡜⣧⢻⠼⣿⠀⠀⠀⠀⠀⠀⠀⠀⣻⣿⣳⡄⠐⠂⢹⡑⢦⡀⡜⡢⣌⠉⠁⣠⢮⢡⢢⡜⢾⢸⠐⠂⠸⠤⠽⣎⡔⢠⢓⢸⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⣿⣟⡿⡜⣧⢻⣜⡇⡖⠀⠀⠀⠀⠀⡠⠊⠈⠟⣯⠇⠀⠀⡔⢉⠶⡱⣭⢳⡝⣗⣾⡝⣮⢳⢧⡞⢹⢂⠀⠀⠀⠀⠀⠀⠑⢮⡣⠼⡆⠀⠀⠀⠀⠀",
+    "⠀⢠⣿⡞⣽⡝⣮⢹⢜⡆⠁⠀⠀⠀⢠⠊⠀⠀⠀⠀⠹⣇⠀⣰⣿⠻⡘⡵⣩⢷⣫⡽⢧⣻⣜⡯⢏⡔⢌⠎⡆⠀⠀⠀⠀⠀⠀⠀⠙⣆⢧⠀⠀⠀⠀⠀",
+    "⠀⠈⣿⡝⣾⡝⣮⢹⣎⢧⠀⠀⢀⠔⠃⠀⠀⠀⠀⠀⠀⠉⢀⣿⣽⣷⡏⢶⡹⣾⠁⠠⠀⠌⣅⠸⢘⡹⣸⠀⢻⡀⠀⠀⠀⠀⠀⠀⠀⠘⠷⠀⠀⠀⠀⠀",
+    "⠀⢸⣷⢻⣼⡳⣍⢾⣿⢺⡅⠀⠤⠂⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⢾⣷⣻⣷⣿⣿⣜⣡⢞⣰⠓⠷⡤⣥⠗⢸⠈⢧⠀⠀⠀⠀⠀⠀⠀⠀⠈⡑⡀⠀⠀⠀",
+    "⠀⣼⣏⠷⣎⡷⡭⣞⣯⠽⣇⠊⡄⠀⠀⠀⠀⠀⠀⠀⠀⢲⣿⣯⣿⣟⢯⣿⠿⣛⡏⡞⢮⣽⡈⠆⠈⠁⢀⠘⡀⠸⡧⠀⠀⠀⠀⠀⠀⠀⠀⠰⠠⡀⠀⠀",
+    "⠀⣿⣎⠿⣜⣳⣓⣯⣟⢦⠇⡐⠀⠀⠀⠀⠀⠀⡐⡑⣆⣿⡿⣽⡿⠮⠇⠋⠱⢌⣿⣹⢳⡞⠐⠀⠀⠀⠂⠌⡀⠀⢿⣰⢯⡄⠀⠀⠀⠀⠀⠀⣽⣓⡀⠀",
+    "⢸⣽⡞⣽⢫⡷⡭⣿⡾⡇⣰⠀⢀⠀⡀⢀⢀⡠⣢⠃⣻⢿⡽⠟⠁⠀⠀⠀⠀⠈⣷⣯⢷⣻⠀⠀⠀⠀⠈⡔⠠⠀⠸⡿⡰⣞⣄⠀⠀⡀⠀⠀⢩⢞⠑⡄",
+    NULL
+};
+
+static char *mikuart_10[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⣤⣤⣤⣀⣀⡀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢄⢀⠀⡀⣠⣴⣾⣿⠿⠟⠛⠛⠛⠿⠿⠿⠽⠿⠿⠿⠿⠿⢶⣦⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⡿⡵⣯⣾⣿⣿⠟⠉⢀⣤⠶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⢫⣮⢿⣿⡿⠛⠁⠠⠔⢋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠈⠻⣷⣦⠠⣃⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣾⢟⣵⡿⢻⡿⠋⠀⠀⣠⢴⡾⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠈⢻⣷⣏⢫⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⢸⣿⣠⠋⠀⡠⣪⢞⡵⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣧⡻⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⡙⢾⣿⣸⡟⠁⠀⢠⠞⠁⠋⠀⠀⡴⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣷⡹⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠁⡇⢸⣿⠋⠀⢀⡶⠃⠀⠀⢠⠃⠜⠁⠀⣀⠀⠀⠀⠀⢀⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠨⣿⠏⣿⣇⡀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡏⠀⡄⡼⠁⠀⢀⣾⠁⠀⠀⠀⡜⡸⠀⠀⣰⢻⠀⠀⠀⠀⢸⠉⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣆⠀⠀⠀⠀⠀⢿⢸⣿⢻⢱⡄⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁⢀⡟⠀⢠⢃⣾⠇⠀⠀⠀⢰⠁⠀⠀⣰⢃⢸⡄⡄⠀⠀⢸⢀⠘⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⢸⠀⠀⠀⢸⣾⠃⠈⠈⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡎⢠⠞⠀⡰⠃⣼⠏⠀⠀⠀⠀⡜⠀⠀⢰⠃⠉⠸⡇⣧⠀⠀⢸⠈⢦⠘⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢱⡀⠁⠀⠀⢸⡿⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣵⠃⠀⢰⠁⣼⠏⠀⠀⠀⠀⢀⠇⠀⢠⠟⠒⠒⠴⣷⣿⡀⠀⢸⠂⠀⠱⣄⠻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧⠀⠀⠀⠈⠀⠀⠀⠀⠣⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣠⡾⢋⠀⢀⠇⣸⠏⠀⠀⠀⠀⠀⡸⠄⢀⠎⠀⠀⠀⠀⠸⣇⢣⠀⢸⡄⠀⠀⠈⡴⠞⣆⠀⠀⠀⠀⠀⠀⠀⠀⠘⡆⠀⠀⠀⠀⠀⠀⠀⢰⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⡾⢟⡇⡘⠃⡜⣼⣯⠀⠀⠀⠀⠀⠀⡇⢀⡞⠀⠀⠀⠀⠀⠀⢻⠈⢧⠸⡇⠀⠀⠀⠀⠀⠙⢆⠀⠀⠀⠀⠀⠀⠀⠀⢹⡀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠐⠉⠀⡸⠀⠃⢰⣻⣯⠇⠀⠀⠀⠀⠀⢸⢁⣾⣤⣀⠀⠀⠀⠀⠀⠀⠀⠈⢷⡇⠀⠀⠀⠀⠀⠀⠈⠧⡀⠀⢠⠀⠀⠀⠀⠀⢧⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⢀⣷⢣⠎⠀⠀⠀⠀⠀⠀⢹⡞⠀⠉⠛⠿⣶⣬⡒⠄⠀⠀⠀⠈⠋⠀⠀⠀⣀⡀⠀⣀⣀⣼⣦⡀⢇⠀⠀⠀⠀⠸⣧⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⣼⣯⠏⢀⣀⡀⠀⠀⠀⠀⢸⡇⢰⠿⠿⠿⠟⠛⠛⠃⠀⠀⠀⠀⠀⠀⠀⣯⣴⣾⡿⠛⠛⠉⠉⠳⡞⡆⠀⢀⣀⢰⠻⣆⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⣿⠋⠀⡜⠀⡇⠀⠀⠀⠀⢸⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⠛⠿⢷⣶⠀⡼⠀⠹⣀⣺⠈⡏⠇⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⡏⠀⠜⠁⠀⢀⠃⢰⠃⠀⣰⡆⠀⢸⠉⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢧⣄⣴⠋⢿⡀⢹⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢠⠇⠀⠀⠀⠀⡞⠀⢸⢀⡞⠁⣸⠀⢸⣄⠀⢣⡀⠀⠀⠀⠀⠀⡤⠤⠤⢄⣀⠀⠀⠀⠀⠀⠀⠀⢀⠞⡟⡎⡧⠨⠀⠀⡇⠈⡇⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⢠⠇⢀⣿⠏⠀⡰⢹⠀⢸⠈⠳⣤⣥⣄⣀⣀⣀⡀⠣⡀⠀⢀⠔⠀⠀⠀⠀⠀⣀⡴⠃⣼⡇⢠⠛⡄⠀⠀⢡⠀⢺⠀⠀⠀⠀⠀⠀⢰⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⡞⠀⠀⠀⠀⡼⠀⢸⠃⠀⢠⠃⠀⡆⢸⠀⠀⠈⠉⢻⣿⣿⣿⣿⡇⠈⠉⠁⠀⠀⠀⣠⠶⠾⠧⠄⠐⣻⢠⠃⠀⠱⡀⠀⠘⡄⠈⣆⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣰⣣⠤⠎⠉⠽⠁⠀⠘⠀⡲⠏⠀⠀⢱⢸⠀⠀⠀⠀⠀⠘⠀⣷⢄⠑⠦⠤⠒⢂⣩⡮⡞⠀⠀⠀⠀⢠⣧⠃⠀⠀⠀⢣⠠⠀⠃⠀⠘⠍⠙⢦⠤⣕⠾⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢰⢹⡀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠀⣄⡀⠈⢿⠀⠀⠀⣰⢞⠇⠀⠘⠀⠙⣢⣠⠖⠉⠈⠀⠀⠈⢢⣀⠀⠰⠃⠀⠀⢀⡴⡞⠉⠀⠀⠀⠀⠀⠀⠈⠀⢸⠎⡇⠀⠀⠀⠀",
+    "⠀⠀⠀⢀⣾⣄⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣝⠢⡌⠀⠀⢸⣿⡆⠀⠀⠀⠀⢀⡨⠶⢀⡀⠀⣠⢦⡀⣸⣿⠀⠀⠀⣠⢞⣩⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⡼⢱⠀⠀⠀⠀",
+    "⠀⠀⠀⣼⣿⣾⣷⣍⠲⢄⡀⠀⠀⠀⠀⠀⢀⣾⣿⡷⣌⢢⡀⣾⠛⣿⡀⠀⠀⣠⡏⠀⠀⠀⢱⣘⢧⣠⢿⡏⢻⡧⢠⠟⡵⢿⣿⣧⠀⠀⠀⠀⠀⠀⣀⡤⢞⣡⣾⣾⣌⣆⠀⠀⠀",
+    "⠀⠀⢰⣿⣿⣿⣿⣿⣿⣶⣬⡑⠲⢤⣀⣠⣾⣿⣿⠃⠈⢢⢻⡇⠀⠙⠷⠞⠋⠉⢷⠀⠀⢠⡋⠛⠻⠻⠟⠁⠈⣻⢇⠞⠁⣹⣿⣿⣷⣄⣀⠤⠖⣋⣥⣶⣿⣿⣿⣿⣿⣼⡄⠀⠀",
+    "⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣬⣌⣉⠙⠛⠓⠒⠚⣠⠏⠀⠀⠀⠀⠀⠀⢸⠀⠀⢸⡀⠀⠀⠀⠀⠀⠀⢿⡘⠒⠒⠚⠛⠋⣉⣨⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀",
+    "⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣭⣽⠿⣹⠁⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠸⡇⠀⠀⠀⠀⠀⠀⠀⠸⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢧⠀",
+    "⢾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⡴⡏⠀⠀⠀⠀⠀⠀⠀⠀⡟⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠈⣿⡄⠙⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⢇",
+    "⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⢠⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠀⢠⣀⣀⣀⣀⣦⠀⢹⣧⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣮",
+    "⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⠘⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠀⠀⠉⠉⠉⠉⠁⠀⠀⢿⣶⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿",
+    "⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⠀⠀⢰⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿",
+    NULL
+};
+
+static char *mikuart_11[] = {
+    "⠀⠀⠀⠀⠀⠀⢀⡤⣢⠟⢁⣴⣾⡿⠋⢉⠱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠑⠒⠦⢄⣀⣴⠟⢡⣠⣼⣿⡿⢳⣄⡀⠀⠀",
+    "⠀⠀⠀⠀⠀⢀⣾⡿⠃⣠⣿⣿⠿⠂⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢲⡿⠋⢰⣾⣿⣿⡟⠀⠀⠈⠙⢆⠀",
+    "⠀⠀⠀⠀⠀⡜⠻⣷⣾⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣁⣰⢸⣿⢻⠟⢀⠀⠀⠀⠀⠀⠁",
+    "⠀⠀⠀⠀⠰⠀⠀⢙⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣯⡀⠀⢃⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢠⠎⠀⠀⠀⠀⠀⠀⣼⠀⢀⠀⠀⠀⠀⠀⢠⣷⡀⠀⠀⠀⠀⡀⠄⠀⠀⠀⠀⢻⣿⣿⣿⣧⠑⠀⣢⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⡰⠃⢀⠄⠀⠀⠀⠀⣼⡿⡆⢸⠀⠀⠀⠀⠀⠈⣿⢷⡄⠀⠀⠀⠱⡀⠰⡀⠀⠀⠈⢿⣿⣿⣿⣧⠀⢸⣧⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠡⢢⠋⠀⠀⠀⠀⣼⡟⠀⣇⢸⡆⠀⠀⠀⡄⠀⢿⠀⢳⡄⠀⠀⠀⢳⠀⢳⠀⠀⠀⠈⣿⣿⣿⣿⣷⣘⡟⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢀⠇⠀⠀⠀⠀⣸⡿⢤⠤⠸⡸⣷⠀⠀⠀⢱⠀⣾⡤⠤⢿⡤⢀⡀⠀⢧⠘⡆⠀⠀⠀⢸⡟⠻⢿⠟⣿⣷⡄⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⡞⠀⠀⠀⠀⢰⡿⢠⠇⠀⠀⢳⣿⢇⠀⠀⠈⡇⣿⡇⠀⠀⠻⣄⠀⠀⠘⡆⡇⠀⠀⠀⠀⣇⢀⡏⠀⣿⡿⣄⠀⠀⠀",
+    "⠀⠀⠀⠀⢰⠁⠀⠀⠀⠀⣿⠁⣄⣀⣀⡀⠈⢿⡜⡄⠀⠀⢹⣿⡇⠐⢄⣀⠘⢧⡀⠀⠹⣿⠀⠀⠀⠀⢸⣿⣷⣶⣿⡇⢹⡇⠀⠀",
+    "⠀⠀⠀⠀⠾⠀⠀⠀⠀⢸⣧⣾⠟⢉⣽⣿⣦⠈⢷⡘⣆⠀⠸⡟⣷⣶⠟⠛⢻⣷⣦⣀⠀⢻⠀⠀⠀⠀⢸⣏⣩⣼⣿⡇⠈⣷⠀⠀",
+    "⠀⠀⠀⠃⠀⠀⠀⠀⠀⣿⡿⠁⠀⣠⣾⣿⣿⠀⠈⢿⠺⡆⠀⣧⢸⠀⠀⢀⣹⣿⣿⣿⣷⣼⣤⠀⠀⠀⢸⣿⣿⣿⣿⠀⠀⣿⠀⠀",
+    "⠀⠀⣠⠄⣀⠀⠀⠀⢠⣿⡇⠀⠀⢻⢻⣟⢿⠀⠀⠈⠣⠈⠓⠾⠀⠀⠀⣿⣿⢿⣿⣿⠘⡇⡞⠀⠀⢠⣾⣿⣿⣿⡏⠀⠀⢹⠀⠀",
+    "⠀⠀⠛⠀⣿⠀⠀⠀⢸⣿⣿⡀⠀⠈⠃⠐⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣄⣐⣠⠏⢠⣿⠁⠀⠀⢸⣿⣿⣿⣿⠀⠀⠀⢸⠀⠀",
+    "⠀⠀⠀⠀⢹⡆⠰⡀⢸⡟⠩⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠃⠀⠀⠀⢸⣿⣿⣿⠟⠀⠀⠀⠘⠀⠀",
+    "⠀⠀⠀⠀⢎⣿⡀⢱⢞⣁⣀⡿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⡏⡼⠀⠀⠀⣾⣿⠋⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠈⠿⠻⡇⠀⠀⠒⠢⢵⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣽⠁⠀⠀⢠⡿⢹⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⡀⠀⠀⠀⠀⠀⠀⡟⣦⡀⠀⠀⠀⠈⠓⢄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣴⢿⡇⠀⠀⡄⣸⣇⣼⣀⣀⣀⠀⠀⠀⠀⠀⠀",
+    "⡀⠀⠀⠀⠀⠀⢰⠇⣿⢸⣦⡀⠀⠀⠀⠀⠈⠲⣄⡀⠀⠀⠀⠀⠀⣀⡤⠒⢉⡴⠃⣸⠀⠀⢰⣿⣿⣿⠃⡤⠊⠁⠉⠑⢄⠀⠀⠀",
+    "⡇⠀⠀⠀⠀⠀⢸⠀⣿⣾⣿⢿⠲⣄⠀⠀⠀⠀⠘⠟⣦⣤⣴⡒⠉⢀⡠⠖⠉⠀⣠⠃⠀⣠⣿⣿⡿⠁⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢸⠀⣿⠛⢿⠈⢢⠏⠀⠀⠀⠀⠀⣰⣏⣀⣿⠗⠊⠁⠀⠀⣠⣾⠃⢀⡴⠿⠛⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢸⢀⠇⠀⠈⢠⠃⠀⠀⠀⠀⠀⢰⠟⠁⠀⢹⢇⠀⣀⠴⠊⡱⠥⠔⠋⠀⠀⢰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢸⡟⠀⢀⡴⠁⠀⠀⠀⠀⠀⢠⡟⠀⠀⣰⢿⡘⣾⡅⠀⠀⠀⠀⢀⠄⠀⢠⠏⢀⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢸⠀⣰⣿⠀⠀⠀⠀⠀⠀⢠⣿⠃⢀⡾⡇⠘⠻⡿⢷⡀⠀⠀⠒⠁⠀⢠⠏⢀⠏⣸⠃⢻⠏⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⣧⣾⣹⣿⠀⠀⠀⠀⠀⢠⠏⢉⠀⡞⣰⡇⠀⣴⣥⠞⢷⠀⠀⠀⠀⣠⠎⠀⠸⣶⠋⣠⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_12[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣤⣄⣤⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⣄⣄⣠⣤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⣿⣿⢿⣿⣿⣿⣿⡢⠀⠀⠀⠀⣀⣄⣤⣶⣶⣿⣿⠶⠶⠷⢶⣾⣿⣷⣦⣶⣄⣄⢀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⢿⣿⣯⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢀⣾⣿⡿⣽⣿⣿⣿⡽⣟⣿⣷⣤⣶⡿⠿⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠙⠻⠿⣾⣦⣤⣾⣿⡿⣯⣿⣿⣿⣯⣟⣿⣷⣆⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢠⣿⣿⡿⣽⣿⣿⣿⣿⣿⣽⣾⠿⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⢿⣿⣽⣿⣿⠿⣿⣿⣾⡽⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣠⣿⣿⡿⣽⣿⡿⠛⢻⣷⡿⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣷⣶⣷⠿⢿⣿⣿⡽⣿⣿⣦⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣰⣿⣿⡿⣽⣿⣿⢁⣴⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣷⣄⢀⢻⣷⣿⣽⣻⣿⣖⡀⠀⠀⠀⠀",
+    "⠀⠀⠀⣼⣿⣿⢿⣽⣿⡿⣡⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢗⢆⠀⠀⠀⠀⠀⠀⠀⠀⠈⢿⣷⡊⢿⣿⣷⣯⢿⣿⣖⡀⠀⠀⠀",
+    "⠀⠀⠀⢼⣿⣟⣿⣟⣿⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢛⢣⡀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣤⣿⣿⣟⣿⣿⣿⠇⠀⠀⠀",
+    "⠀⠀⠀⠀⢹⣿⣷⣿⣽⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡸⡅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢣⡙⡄⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣳⣿⣿⣿⠁⠀⠀⠀⠀",
+    "⠀⠀⠀⢀⣾⡿⠈⢹⣿⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠄⠀⠀⣇⠃⠀⠀⠀⠀⠀⠀⣼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢳⡘⡄⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⠟⢇⠘⣿⣇⠀⠀⠀⠀",
+    "⠀⠀⠀⣼⣿⠃⠀⣾⣿⠁⣰⠁⠀⠀⠀⠀⠀⠀⠀⡾⠀⠀⣰⣿⣆⠀⠀⠀⠀⠀⠀⡏⡆⠀⠀⠀⢳⡀⠀⠀⠀⢀⠘⣆⠹⡀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡏⠼⡀⢹⣷⡆⠀⠀⠀",
+    "⠀⠀⢠⣿⡇⠀⢠⣿⣏⣴⡇⠀⠀⠀⠀⠀⠀⢀⣸⡃⠀⣰⡿⠹⣿⡄⠀⠀⠀⠀⠀⣿⣿⡆⠀⠀⠀⢿⣦⡀⠀⠀⣆⢹⢰⣧⡀⠀⠀⠀⠀⠀⠀⠀⢻⣿⢂⡇⠈⣿⣷⠀⠀⠀",
+    "⠀⠀⣾⡿⠀⠀⢸⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⣿⣿⠁⣰⡿⠁⠀⢹⣷⡀⠀⠀⠀⢀⣿⡿⢿⣦⠀⠀⠈⣿⣿⣄⠀⢸⠞⡬⣿⡇⠀⠀⠀⠀⠀⠀⠀⢸⣿⡆⢣⠀⢸⣿⡆⠀⠀",
+    "⠀⢠⣿⠇⠀⠀⢸⠿⣿⡿⠀⠀⠀⠀⠀⠀⠀⣿⣗⣰⣿⠁⠀⠀⠀⢻⣷⡀⠀⠀⢠⢿⣷⠈⠻⣷⣄⠀⠘⣿⣿⣧⡀⡇⡒⣿⡇⠀⠀⠀⠀⢠⡄⠀⠸⣿⡇⣹⠀⠀⣿⣧⠀⠀",
+    "⠀⣼⣿⠀⠀⠀⢎⢲⣿⠇⠀⣰⠀⠀⠀⠀⠀⣿⣷⣿⠃⠀⠀⠀⠀⠀⠹⣷⡀⠀⠀⣿⣿⠀⠀⠈⠻⢿⣦⣜⣿⣟⢿⣶⡡⣿⡷⠀⠀⠀⠀⢸⣱⠀⠀⣿⣗⢸⠀⠀⢹⣯⡄⠀",
+    "⠀⣾⡇⠀⠀⠀⢘⣾⡿⠀⢰⣹⠀⠀⠀⠀⠀⣿⣿⡟⠀⠀⠀⠀⠀⠀⠀⠙⢿⣆⠀⢻⣿⡀⠀⠀⠀⠀⠉⠛⠿⢿⠎⠻⣿⣿⣟⠀⠀⠀⠀⢸⣤⣧⠀⢻⣿⣈⠀⠀⠘⣿⡇⠀",
+    "⠈⣿⠃⠀⠀⠀⢸⣿⢃⣤⣿⣿⣇⠀⠀⠀⠀⢿⣿⠁⠀⠀⠀⠀⣀⡀⠀⠀⠈⠻⣷⣬⣿⣇⠀⠀⠀⢀⣀⠀⠀⠀⠀⠀⠈⢻⡏⠀⠀⠀⠀⣿⣿⣿⣶⣼⣿⣦⠀⠀⠀⣿⡷⠀",
+    "⢰⣿⠀⠀⠀⠀⢿⣿⣿⣿⣿⡽⣿⣆⠀⠀⠀⢸⣿⠀⠀⠀⠀⢸⣑⣚⡆⠀⠀⠀⠈⠙⠿⣿⠄⠀⢰⡫⢜⡇⠀⠀⠀⠀⠀⣿⡇⠀⠀⠀⣸⣿⣟⣾⣿⣿⠿⡏⠀⠀⠀⢸⣧⠀",
+    "⢸⣿⠀⠀⠀⠀⠘⣼⣿⢾⣿⣿⡽⣿⣆⠀⠀⠈⣿⡇⠀⠀⠀⠈⠶⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠳⠽⠃⠀⠀⠀⠀⠀⣿⠇⠀⠀⣰⣿⡿⣾⣿⣽⣿⢲⠁⠀⠀⠀⢸⣿⠀",
+    "⢸⣿⠀⠀⠀⠀⠀⠹⣿⣾⠻⣿⣿⡽⣿⣦⡀⠀⢹⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀      ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠀⠀⣴⣿⣿⣽⣿⢽⣿⣏⠆⠀⠀⠀⠀⠀⣿⡃",
+    "⢸⣿⠀⠀⠀⢦⡀⠀⢻⣿⡄⠙⢻⣿⣽⣿⣿⣦⡈⢿⣇⠀⠀⠀⠀⠀⠀⠀       ⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⠇⣠⣾⣿⣿⣿⠋⠁⣼⣿⠋⠀⣠⡏⠀⠀⠀⣿⡆",
+    "⠸⣿⠀⠀⠀⠀⠙⢗⠤⣻⣯⡄⠀⠙⢛⣿⣿⣿⣿⣾⣿⣷⣶⣤⣤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣠⣤⣶⣾⣿⣿⣿⡟⠋⠀⠉⢁⣠⣾⡿⣁⠤⡺⠎⠀⠀⠀⠀⣿⡇",
+    "⠀⣿⡄⠀⠀⠀⠀⠀⠉⠒⠽⠿⣿⣴⣴⣿⣿⣽⣿⣽⣻⢏⡈⠉⠙⠛⠿⠻⠻⠿⠿⠿⠿⠿⠿⠿⠻⠿⠟⠛⠋⠉⠛⠟⣋⣥⣤⣶⣾⣿⠿⠟⠛⠑⠒⠋⠀⠀⠀⠀⠀⢀⣿⠀",
+    "⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⣿⣿⣾⣿⣿⣿⣿⣿⣾⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣿⡟⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀",
+    "⠀⣻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣉⠙⠛⠿⣿⣤⣀⣈⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣐⣿⠟⠉⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀",
+    "⠀⣿⣿⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠳⡢⢌⠹⣿⡿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⢋⠴⡲⠝⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠄⢸⡿⡇⠀",
+    "⠀⠘⣿⣧⠈⠳⡤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣑⣹⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⡏⠖⠉⠀⣀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠋⣠⣿⡟⠀⠀",
+    "⠀⠀⠐⢿⣷⡀⠈⠓⠽⢒⣒⣐⣂⣒⠒⠒⠐⠢⠌⣓⣢⣄⡈⢺⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣡⣴⣮⣝⣐⠓⠚⠨⠽⠂⣖⣂⣖⡒⠭⠓⠉⣀⣴⣿⠉⠀⠀⠀",
+    "⠀⠀⠀⠈⠻⢿⣷⣄⡀⠀⠀⠀⠀⢀⣀⣤⣴⣾⣿⠿⠿⠿⠿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠿⠟⠛⠛⠛⠻⢿⣷⣦⣤⣀⣀⣀⣀⣀⣠⣴⣾⡿⠋⠁⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠙⠻⠿⣿⡿⢿⣿⠿⠿⠋⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠻⠿⠻⠛⠿⠛⠋⠁⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_13[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⢤⣤⠤⠀⢤⣠⠤⠒⠒⠒⡒⠛⢛⠛⠛⠒⠢⠤⣀⡀⠀⠀⠀⠀⠀⣀⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠴⠒⠉⢀⡴⠋⠀⠀⠀⠀⠀⠄⣀⠀⠀⠈⠉⠒⢽⡢⣄⠀⢤⡀⠉⠲⣄⠰⣾⣟⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠊⠁⠀⠀⣴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⠀⠀⠀⠉⠪⠳⡄⠉⠢⡀⠈⢷⣿⣿⢾⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⡠⠋⠀⠀⢀⡴⡞⠁⠀⠀⠀⠀⢸⠁⠀⠀⠀⠀⠀⠀⠈⠃⠀⡄⠀⠀⠐⢜⢆⠀⠑⡄⠀⣿⣿⣟⣿⣿⣿⠛⠉⠛⠛⠳⣦⡀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢀⠞⠁⠀⢀⣴⠏⢰⠃⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡆⠀⠀⠈⢞⣆⠀⠈⢆⠸⣿⣿⢾⣿⣿⡂⠀⠀⠀⠀⠀⠻⣆⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⠟⠀⢀⣠⣿⠃⢀⡇⠀⠀⠀⠀⠀⠀⣼⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⠀⠀⠀⠸⡼⡄⠀⠘⣇⢿⣿⣟⣿⣿⣧⠀⠀⠀⠀⠀⠀⠸⡄⠀⠀⠀⠀",
+    "⠀⠀⠀⢠⠏⠀⢠⠣⣰⠃⢀⠞⡇⠀⠀⠀⠀⠀⠀⡧⠘⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣇⠀⠀⠀⢹⢳⠀⠀⢹⡞⣿⣿⣞⣿⣿⣆⠀⠄⠀⠀⠀⠀⠙⡄⠀⠀⠀",
+    "⠀⠀⢀⠏⠀⣠⠣⢱⠃⠀⠈⢸⡇⠀⠀⠀⠀⠀⠀⢹⠀⠀⠹⣤⠀⠐⢤⠀⠀⠀⠀⠀⣿⡀⠀⠀⠀⡟⡇⠀⠀⣿⣸⣿⣿⡽⣿⣿⣄⠀⠀⠀⠀⠀⠀⢹⡄⠀⠀",
+    "⠀⠀⡞⠀⣰⠃⢆⡏⠀⠐⢀⡟⢱⡀⠠⡀⠀⠀⠀⢸⡆⠀⠀⠈⠳⣄⠀⠑⡄⠀⠀⠀⢸⡇⠀⠀⠀⢹⢳⠀⡀⢻⣶⢻⣿⣿⢿⣿⣿⣄⠀⠀⠀⠀⠀⠀⢣⠀⠀",
+    "⠀⢸⠃⢰⠇⢸⢸⠃⠀⣠⡾⠀⠀⢧⠀⢱⠀⠀⠀⠀⡇⠀⠀⠀⠀⠈⠳⢄⡈⠂⠀⠀⣸⡃⠀⠀⠀⢸⢸⠀⢣⣼⣿⡏⣿⣿⡿⠿⠟⢻⡄⠀⠀⠀⠀⠀⠘⡄⠀",
+    "⠀⡏⢀⣿⠀⡏⣿⠀⢀⣿⣃⣀⣀⣀⣳⡳⣀⠀⠀⠀⢻⠀⠀⠒⠒⠶⠖⠒⠓⢦⣀⠀⢱⠃⠀⠀⠀⠠⡼⠀⢸⣿⣿⣏⢾⠁⠀⠀⠀⠸⣧⠀⠀⠀⠀⠀⠀⢡⠀",
+    "⢰⠇⡾⣿⠀⠃⣿⠀⢸⡏⠉⠈⢉⣩⣩⣟⣿⣧⡀⠃⠘⡇⠀⠀⠀⠠⣲⣮⣤⣤⣽⣿⡚⠀⠀⠀⢀⠘⡇⠀⣿⣿⣿⣯⢸⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⡄",
+    "⢸⢰⠇⣿⠀⠀⢹⡀⢸⡇⣠⣶⣿⣿⣿⣷⣽⠻⣗⢆⢠⢻⡀⠀⢠⣾⠿⣿⣿⣿⣿⠿⣇⠀⠀⠠⠀⣾⠃⢰⣿⢻⣿⣿⣿⣶⣤⠄⠀⠀⢿⡀⠀⠀⠀⠀⠀⠀⢃",
+    "⣼⡎⠀⣿⠀⠀⣎⣇⢼⡿⣿⠉⣯⣽⣿⣿⡞⠁⠈⠻⣝⢯⣧⡀⠀⠸⣿⢿⣿⣿⣿⠀⢘⣇⠀⠀⢰⡏⠀⣾⡟⢸⣿⣿⡿⡿⢿⠀⠀⠀⢸⡆⠀⠀⠀⠀⠀⠀⠸",
+    "⢻⠃⠀⢹⠀⠀⠸⣞⢿⣿⡙⠄⠻⠿⠿⠿⠇⠀⠀⠀⠀⠉⠹⣦⠀⠀⠈⠉⠉⠁⠀⠀⠈⢸⡄⠐⡞⠀⣼⣿⠁⣸⣿⣿⣿⣿⡏⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀",
+    "⠈⠀⠀⠘⡇⠠⠀⣿⠈⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡿⠁⣼⣿⠃⠀⣿⡿⣽⣿⣿⠇⠀⠀⠀⠘⣿⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢿⠀⠀⣾⣇⢻⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣃⣾⣿⣿⠀⢰⣿⡿⣽⣿⣿⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢸⡆⠀⣿⣿⣌⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⢀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣼⠟⢡⡟⣿⡿⢀⣿⣿⣿⣿⣿⡏⠀⠀⠀⠀⠀⢻⡀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢸⣇⠌⠿⣿⣷⣞⢻⣧⡀⠀⠀⠀⠀⠿⠗⠶⠒⠛⠃⠀⠀⠀⠀⠀⠀⢀⡰⣻⡟⢠⣾⣿⡿⡷⠿⠿⢿⣿⡿⠿⠃⠀⠀⠀⠀⠀⢸⡁⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣼⢻⣌⠀⠛⣿⣿⣶⢽⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⣾⠿⣠⣿⠋⠁⠘⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⡇⠀⢿⠀⡃⢽⣿⣿⣦⣽⣿⣿⡖⢤⡀⠀⠀⠀⠀⠀⠀⣠⠤⠖⠋⠁⢰⣯⣿⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⡇⠀⠀⢰⠁⠚⣿⣿⣿⠛⣿⣿⡇⠀⠈⠑⢢⣤⣤⡖⠋⠀⠀⠀⠀⣤⣾⣿⢻⡟⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⢸⠇⠀⠀⡘⢌⡱⢽⣞⡿⠀⣻⢿⡇⠀⠀⢀⣼⣥⡀⠀⠀⣠⡤⠒⠋⠉⠉⣿⠀⠈⠈⠙⠻⢦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⣼⠀⠀⠀⡘⠤⡹⢸⣯⡇⠀⣿⢸⡇⠀⠀⢼⠁⡀⣩⣷⣯⡁⠀⠀⠀⠀⢄⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⡟⠀⠀⠀⢘⠠⣝⠢⢿⡇⠀⣟⢸⡗⠀⠀⡞⠐⣾⠟⠅⠈⢷⣄⠀⠀⠀⠀⠈⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢀⠇⠀⠀⠐⠨⢐⢣⡑⢾⡇⠀⡿⢸⣏⢀⡼⢠⣾⣿⠁⠀⢀⣠⣿⣆⠀⠀⢀⡈⠁⢙⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠂⠀⠀⠀⠀",
+    "⠀⠀⢸⠀⠀⠀⠀⡍⢢⢃⡜⣹⡇⠀⡏⣼⠟⠉⣰⣿⡿⣿⣤⣤⣔⡿⠀⠹⣧⠐⠧⠋⣠⣾⠟⠛⠷⠤⠤⠒⠒⠒⠤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠸⡇⠀⠀⠀⠀⠀",
+    "⠀⠀⡞⠀⠀⠀⠠⣐⣢⡧⠼⠿⠧⠴⢿⠃⣠⣾⠟⠋⢀⡟⠀⠀⣸⠃⠀⠀⠙⢷⣆⣾⡟⣻⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠲⣄⠀⠀⠀⠀⠀⠀⡇⠀⠂⠀⠀⠀",
+    "⠀⢠⡇⠀⠀⣠⠞⠉⠀⠀⠀⢀⣠⢢⣷⠾⠋⠁⠀⢀⡞⠀⠀⠀⡏⠀⠀⠀⠀⠀⠉⠉⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢦⠀⠀⠀⠀⠀⣿⠀⠀⡀⠀⠀",
+    "⠀⢸⠀⢠⠞⠁⠀⠀⠀⠀⢀⣾⢃⠎⠀⡀⡀⢀⢠⠞⠀⠀⠀⢰⠇⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣇⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_14[] = {
+    "",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠦⣄⣠⠴⠒⠒⠉⠒⠶⣄⡏⣶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣠⡞⣡⠀⢠⡀⠀⢦⡀⢹⣷⣼⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠁⣿⠟⣷⣿⢦⡈⣇⠀⢻⣿⣈⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⡇⣶⣻⣀⠘⣿⣀⣹⣿⣰⣼⡟⣯⠟⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡇⣿⡿⠿⠋⠉⠋⠛⢿⣿⣿⡇⠈⢦⡸⣾⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡇⠛⣷⣄⠀⠀⠀⠀⣸⠟⠃⠉⠀⠈⢷⣩⡻⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠹⡄⠈⠙⠒⢤⣴⣾⠉⠁⣀⡀⠀⠀⠀⠹⣟⢮⡳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⠀⣿⠀⣀⣴⣿⡏⣀⡬⠟⠁⠈⣆⠀⠀⠀⠘⢧⡉⢿⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡿⣿⠀⢻⣫⠉⣽⡟⠉⡅⢀⣆⠀⢠⣿⠀⠀⠀⠀⠀⠹⣦⡉⠻⢦⡀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢗⣿⢀⡷⠁⣸⡿⠁⠀⠀⢸⣿⠃⣄⣈⡆⠀⠀⠀⠀⠀⠈⠫⣱⠦⣌⡓⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣇⣾⣿⢟⡇⢀⣿⡇⠀⢀⣰⢸⡌⢿⣿⢻⡟⣃⠀⠀⠀⠰⡂⠠⠌⠲⢤⣙⣻⠛⠓⠶⢦⡤⣄⣀⡀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⣻⣿⠏⣾⠃⢸⢽⡇⠀⡏⠁⡶⠁⠈⣿⣎⡷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⠒⠶⢤⣀⠈⠻⣄⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣿⠟⠁⡼⠀⣿⠀⡟⢸⡇⢰⠃⢸⠇⠀⠀⢹⣷⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣷⣄⠘⣧⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣾⠟⠋⠀⣠⡼⢁⣼⣿⢠⣧⢾⡇⠘⡀⠸⡇⠀⠀⠘⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡉⠚⢧⠹⣷⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠖⢋⣽⡿⠥⠖⠚⠉⢁⣴⣾⣿⠃⢈⠀⢸⠇⠀⠁⠀⢳⡀⠀⠀⣿⣿⣽⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠀⠀⠘⢧⡇⠀",
+    "⠀⠀⠀⠀⠀⠀⣀⣤⣾⠛⠁⣠⡼⠋⠁⠀⢀⣀⢀⣴⣿⣿⠟⠁⠀⠀⣷⠋⠂⠀⠀⠀⠀⠳⡀⠀⢹⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡿⠀⠀⠀⢸⠧⠀",
+    "⠀⠀⢀⡠⠖⠋⣩⠶⢋⡴⠋⠁⠀⠀⠿⣭⡿⣿⠿⠟⢉⣷⣄⠀⢀⣼⣿⡄⠀⠀⠀⠀⠀⢀⣹⠄⠀⢹⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠐⡧",
+    "⠀⠀⣸⣄⣴⣛⣡⠞⠋⠀⠀⠀⠀⠀⠀⠀⣭⣤⣴⣾⣿⣿⣿⣷⣿⣿⣿⣷⣤⣴⣶⣾⣿⣿⣿⣆⠀⢈⣿⣷⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢑",
+    "⠀⠰⣏⡿⢫⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣹⠿⠿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⢀",
+    "⠀⢀⣿⡵⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⣿⣿⣿⣿⣿⣿⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⢀⡜⠀⠀⠀⠀⠀⠀⢀⠎",
+    "⢠⢸⡟⠹⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡧⠤⢙⠛⠋⠛⠛⠿⠿⢿⡟⠛⠉⠁⠀⠀⠀⠀⠀⠠⠐⠀⠀⠀⠀⠀⠀⠀⢀⡼⢀⠀⠄⠀⠀⡀⡀⠀⠀",
+    "⢸⣎⡇⠀⠳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢷⠀⡀⢰⡅⠀⠀⠀⠀⠀⡝⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⢋⠞⠀⢠⣮⠎⠀⠀⠀",
+    "⠀⢿⣷⠀⠀⠈⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣶⣿⣇⠀⠀⠀⠀⣰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠋⣠⠋⢀⣴⠟⠁⠀⠀⠀⠀",
+    "⠀⠘⣏⢧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⢹⣻⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⢡⠞⣁⣴⠟⠁⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠸⡄⠳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠳⢄⡀⠀⠀⠘⣿⣿⡯⢶⢧⣿⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⢁⣴⠿⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠹⡄⠙⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⠈⢿⣿⡯⣝⣾⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⡯⢖⡿⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠹⡄⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢻⣿⣿⣽⣿⡇⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⢴⣶⠿⠋⠁⣰⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠘⢦⡀⠀⠙⠢⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣻⢿⣿⡍⠑⠒⠒⣒⣾⣷⠿⠛⣋⡵⠚⠁⠀⣠⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⡀⠀⠙⠓⠒⠀⠀⣀⡀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⣿⣷⡚⠛⠉⠁⠀⠀⠐⠋⢀⡀⢀⡤⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠙⠋⠛⠛⣹⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣻⣿⣿⣿⣿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⢿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⡏⠸⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⠁⠀⢹⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⡏⠀⠀⠈⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⠀⠀⠀⠀⢼⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⠀⠀⠀⠀⣼⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠰⣿⣿⣿⠀⠀⠀⢀⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⡆⠀⠀⣾⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣷⠀⠀⠸⣿⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣿⣿⣿⣻⡇⠀⠀⠈⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⣿⣟⠟⠀",
+    NULL
+};
+
+static char *mikuart_15[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠒⠒⠢⣴⣿⣿⣷⠤⠄⠀⠀⠤⠤⠠⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠋⢀⠀⠀⢀⡿⠛⠋⠀⠀⢀⠀⠀⠀⠀⠀⠀⠈⠑⠢⡀⢀⣴⣿⣿⡦⠤⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣤⡟⣇⠔⠉⠓⠂⣤⣴⢯⡿⠤⣴⣧⣀⣀⠀⠀⠀⡀⣸⣿⣿⠋⠀⠀⠀⠀⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⡝⢠⣧⠐⢂⣿⣿⣿⣎⣼⡏⣿⣿⣳⣷⣹⡏⣥⠉⢱⣿⣿⠇⡆⣠⣄⠀⠀⣌⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⢁⢿⣟⣆⢼⢸⡿⠁⢴⡏⡅⣿⣏⡮⠘⣸⣿⢼⣿⣶⣿⣿⣦⡷⡟⠙⣶⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢸⣾⢿⣼⡌⣿⡷⠛⢶⡇⠣⡟⢻⡶⠻⠻⣆⣾⡇⣿⣿⣿⣿⡇⠀⠀⠏⢳⣿⣿⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡏⣿⣜⣿⣷⢸⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠟⣯⣧⣿⣿⡟⣿⡇⠀⠀⠀⣸⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⠘⢧⣻⣿⣿⠀⠀⠀⠠⠄⢄⠠⠀⠀⠀⣼⣿⣿⣿⡿⠃⣿⢹⠀⠀⠀⡟⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⡆⠀⣿⣿⣿⣶⣤⣀⠀⠀⠀⠀⢀⣠⣼⣿⣿⣿⣿⠃⠀⣹⠈⠀⠀⢰⢻⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⡇⠀⣿⢿⣿⣿⣿⣿⣿⡖⠒⢚⡭⣾⣿⣿⣿⡀⠀⠀⠀⢸⢀⠀⠀⣞⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⣷⠀⢻⣿⣿⡿⠋⢙⢿⠳⣀⣠⣴⣿⣿⡟⠚⠓⠢⡀⠀⢸⢹⢀⡀⣿⣿⣿⣿⣾⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⢠⡘⣿⣿⠀⠀⢸⢸⢠⠛⢿⣿⢻⣿⠀⠀⠀⠀⢻⡄⢸⣸⢸⠇⣿⣿⣿⣿⣿⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⢞⣿⡿⣿⠘⣇⢻⣿⡄⠀⣹⠈⢿⣤⡟⠻⠟⢸⠀⠀⠀⠀⢸⠃⢸⣼⢻⢰⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⣿⣷⠿⠋⢡⣿⠀⣿⠈⣿⣇⠀⢸⠀⠀⠛⡇⠀⠀⠸⢦⠀⠸⠶⣿⠀⢸⣼⡇⡿⣾⣿⣿⣿⠈⠻⣿⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⣾⡿⠛⠉⠁⠀⠀⣼⠋⠀⢣⢧⠈⣿⣠⡇⠀⢘⠀⡗⣮⣽⣇⣿⣤⣤⣤⣿⠀⣿⣿⢸⡇⣿⣿⣿⣿⡆⠀⠙⢿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣳⡏⠀⠀⠀⠀⠀⢠⣧⡇⠀⠸⣾⡄⢻⣿⣿⣿⣿⡀⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⣿⢿⣼⣶⣿⣿⣿⣿⣧⠀⠀⠈⢿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣇⠀⠀⠀⠀⢀⠞⣿⠁⠀⣷⣷⣧⠸⣿⣿⣿⣿⣇⠸⣿⣿⣿⣿⣿⣿⣿⣇⠀⡟⡌⠉⠏⣿⣿⣿⣿⣾⢇⠀⠀⠈⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠻⣦⡀⠀⢀⢎⡼⣿⡄⠀⢹⣧⢿⠀⣿⣿⣿⣧⣹⠀⣿⣿⣿⣿⣿⣿⣿⣿⣄⣧⠁⡇⣰⣿⣿⣿⣿⣿⣿⡄⠀⠀⢸⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠺⣦⢞⡾⢁⣿⠁⠀⢸⣻⣟⡇⢹⣿⣿⣿⣿⡆⡏⣿⡌⣿⣿⣿⣿⡇⢻⡼⢰⣷⣟⣿⣿⡟⠻⣿⣿⣿⣄⡀⣸⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣫⡾⠀⡼⡏⠀⠀⠀⠙⣿⡇⢸⣿⣿⣿⣿⣷⣧⠸⣿⣿⣿⣿⣿⣷⣾⡇⢸⣿⣄⡿⣿⣿⣦⠈⢿⣿⣿⣿⣷⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢮⣿⠃⡰⣻⡇⠀⠀⠀⠀⣿⣿⠘⣿⣿⣿⣿⣿⡿⠃⢻⣿⣿⣿⣿⣿⢙⠁⠈⣿⣿⢹⠹⣿⣿⣷⠛⢿⣿⡿⣾⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡾⢻⣿⡰⣱⣿⠃⠀⠀⢠⠸⣿⡇⢠⣿⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣴⡀⠀⢱⡻⡜⣧⣿⣿⣿⣦⢼⣽⠿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢇⡸⠋⢠⣿⡟⠀⣼⠀⡼⡇⣿⡇⣸⣿⣿⣿⣿⣿⣿⡆⢸⣿⣿⣿⣿⣿⣧⡇⠀⠀⠹⣿⣽⣿⣿⣾⣿⣟⡇⠀⢸⣿⣿⣷⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠴⠋⠀⣰⣿⡿⠁⢼⠍⣼⣻⢱⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣸⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠙⢿⣿⣿⣿⡇⢀⠇⠀⣿⣿⣿⣿⣿⣿⣷⣄⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⡀⠤⣤⣶⡿⢛⣵⡶⢋⣴⣿⠟⣠⡾⢃⣼⠟⣫⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣧⠙⢦⣄⠘⣿⣿⣟⡀⣜⣀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⢀⢔⣭⣶⣿⣿⢥⣾⠟⠋⣰⣿⣿⣿⠞⣫⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠻⣷⣮⣿⣦⡹⠀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠀⠀⠀⠀⠀",
+    "⠀⠀⢠⣻⣿⣿⣿⣿⢞⣋⣤⣴⢿⡻⣯⣿⣵⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⡀⠙⠻⠿⣿⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠘⣿⢸⣿⣿⣿⣟⠿⣹⣶⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⢄⣀⡈⠉⠀⠂⠀⠉⠉⠛⠛⢿⣤⣤⣤⣄⣀⡀⠀",
+    "⠀⠀⠀⠈⠛⢿⣿⣿⣡⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⢿⣾⣎⠻⣿⣿⣿⣿⣿⣿⣿⡿⣿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⣞⣭⠍⠓⠒⣒⣒⣲⣶⣶⣿⠟⠛⠛⣉⣿⣿⠆",
+    "⢠⣶⣾⣿⣿⣛⡛⠛⢛⣻⣿⣿⣿⣿⣟⣿⣯⡉⠁⠀⠀⠀⠀⠙⠿⠽⣾⢽⡿⠝⠺⢝⡇⠀⢜⡩⠖⠋⡿⣿⣿⢿⡿⣚⠷⠚⠈⠙⢿⣷⡀⠉⠙⠛⠒⠒⠛⠛⠛⠋⠁⠀⠀⠸⠟⠉⠁⠀",
+    "⢀⣙⣛⣛⣯⣿⡿⢶⢽⡟⠛⠛⠉⠉⠉⠙⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⠁⠀⠊⠃⠀⠉⠀⢠⣤⡴⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠉⠉⠉⠉⠁⠀⠀⠉⠛⠛⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_16[] = {
+    "⠀⠠⢄⢠⢲⣒⠧⡐⢄⢢⠰⢠⠄⡀⠰⢢⠔⡢⠔⡢⢄⠀⠆⡴⡰⢠⠤⡀⠐⠹⢶⣒⢖⢢⢖⡰⢂⠦⡤⡀⠠⡀⠀⠲⢒⡔⣢⠔⡰⢠⠄⢢⡐⢠⢂⡔⢠⠄⡄⠂⡄⠠⢀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢈⠱⡌⢢⢯⡝⢢⡉⢦⡑⢎⡡⢎⡐⠈⣇⢮⢱⡹⣰⣉⠦⠘⢰⢻⣦⠳⣱⠀⢀⠈⢻⣿⣔⡧⣽⢩⣎⡵⣩⡤⠐⢆⠀⠈⠑⠃⠞⢱⠣⡝⡴⣈⠇⢦⡘⢆⠎⡔⡡⢂⠅⠢⢌⠠⢁⠈⠄⠂⠁⠠⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢠⠣⡜⢣⡛⡌⠧⣜⡡⢚⠥⣚⠤⣊⠄⢺⣬⠳⡼⣱⢎⡼⡀⠀⠑⣾⣧⡳⣍⠀⠣⢄⠘⢿⣾⣵⣻⣜⣷⣣⢿⡵⡈⢧⡀⠃⠜⣠⢂⢄⡉⠐⠹⣌⠧⣘⡍⡜⢢⡱⠌⣌⠑⡠⠒⡈⠄⢂⠡⠈⠄⡐⠀⡈⠀⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⢄⡳⡜⢧⡽⣖⡳⣬⢳⡝⣮⣜⡱⢆⠢⢹⣎⡿⡵⢯⣞⡵⡃⢈⣆⠐⢿⣽⡚⣥⠘⣦⡁⠈⢻⣯⣿⢾⣭⣟⣯⢿⣵⡈⢷⡄⢡⠂⡄⠈⠘⠕⣆⣀⠘⠐⠌⡐⠃⠤⠑⡠⠊⠄⡑⠠⠈⠄⠂⢁⠠⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⣌⡳⣝⢧⣿⣻⣷⣭⢗⣻⢶⣭⢳⣍⢎⠰⣿⣻⡟⣿⢯⣷⡁⢠⢿⣧⡈⢳⣿⡳⠆⢹⣿⣅⡂⢹⣿⢿⣾⣟⣾⡿⣾⣷⠘⣿⡄⠳⣌⢆⠀⠀⠀⠈⠳⣦⡀⠀⠈⠀⠀⠀⠐⠀⠀⠀⠁⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢢⣟⣼⢻⣷⣿⣷⡿⣿⣽⣳⣯⢷⣎⡎⡄⣿⣷⣿⢿⣻⢾⠁⣸⠘⣿⣷⡄⠻⣧⡟⠀⣿⣿⣦⡀⠙⣿⣿⡾⣿⣽⣿⣽⣆⢸⣿⡄⠹⣞⡕⡀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⣹⢾⡽⣻⣿⣾⡿⣿⣷⣻⣷⢯⣿⢶⡹⠄⣿⣿⢾⣿⢿⣻⠀⣷⡂⣿⣿⣿⠄⠹⣿⣃⠈⣉⣉⣉⣀⠙⣷⣿⢿⣽⣾⣟⣿⡀⢿⣷⡀⠛⣿⣮⣆⠀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢫⣿⣽⣻⣷⡿⣿⣿⡿⣽⡿⣿⣾⢯⡟⡆⣹⣿⡿⣯⣿⡏⢘⡮⠓⠉⣁⣤⣴⣆⠹⣷⠈⣿⣿⣿⣿⡄⠙⣿⣿⢯⣿⣾⢿⣇⢸⣿⣷⠀⠱⢾⣻⣧⡀⠀⠀⠀⠀⠀⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢸⣷⡿⣽⣾⢿⣿⣷⣿⢿⣻⣿⢾⡿⣝⠦⢹⣿⣟⣿⣷⠁⢁⣤⣶⣿⣿⣿⣿⣿⣧⠸⡆⢻⣿⣿⣿⣯⣃⠸⣿⡿⣯⣿⡿⣿⠀⣿⣿⡆⠀⠈⠳⣟⣷⡄⠀⠀⠀⠀⠀⠈⢣⡀⠀⠀⠀⢀⠀⠀⠀⠀⡈⠐⠀⠂⠀⠀⠀⠀⠀⠀⠀",
+    "⡇⢿⣟⣿⣽⡿⣷⣿⣯⣿⣿⣽⣿⣻⡽⢎⢸⣿⣿⣽⡞⢰⣟⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠘⣿⠻⣿⡟⢁⣆⠹⣿⣟⣷⣿⢿⡇⣿⢿⣿⠀⠀⠀⠙⢯⣿⣆⠀⠀⠂⠀⠀⠀⠱⡀⠀⠀⠀⠀⠀⠀⠀⠄⡀⢀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⣿⡸⣿⣏⣿⣹⣿⣷⣿⢿⣾⡿⣾⣿⣹⠇⣸⣿⣷⣿⠁⣾⣿⣿⣿⣿⣿⡿⣁⣿⣿⡿⠇⠀⠀⠀⠀⠀⠉⠏⠀⢹⣿⣏⣿⣿⡇⢹⣿⣿⡇⠀⠀⠀⠀⢿⣹⣇⠀⠀⠀⠆⠀⠀⢱⠀⠀⠀⠀⢀⠀⠰⠆⡀⠀⠀⠀⠀⠰⠀⠀⠀⠀",
+    "⢿⣧⢻⣿⣽⣿⣳⣿⣯⣿⣯⣿⣟⣷⣯⠃⣿⣿⣽⡏⣰⣿⣿⣿⣿⡿⢋⣴⡿⠛⠁⣠⣤⠤⠶⠾⠶⣶⣦⣄⠈⠈⣿⣯⣿⣾⡇⢸⣿⣟⣧⠘⣁⠀⠀⠀⠙⣿⣆⠀⠄⠀⠀⠄⠀⢡⠀⠀⠴⠀⠠⠘⡐⡆⠘⠄⡀⠀⠄⠐⠀⠀⠀",
+    "⡞⣿⡎⢿⣾⣻⣽⣷⡿⣽⣾⣯⣿⣻⡼⠃⣿⣟⡾⢠⣿⣿⣿⣿⠟⣱⡿⠋⠀⣠⡾⠋⠀⠀⢀⠀⠀⠀⠉⠻⣷⣄⠸⣿⡷⣿⣇⢸⣿⡿⣿⡄⢯⢄⣀⠀⠀⠈⢻⣦⠀⠀⠁⠀⠀⠀⢂⠀⠂⠀⠀⠄⡑⡀⠀⠁⠒⠀⠊⢐⠀⠀⠀",
+    "⣷⡘⣿⡜⣿⣻⣽⣾⢿⣟⣷⣿⣳⡿⣍⢣⣿⡿⢀⣿⣿⣿⣿⣿⣾⡟⠱⠀⣴⡽⠁⠀⠀⠆⣐⣬⣐⠀⠀⠀⠙⣿⡆⢻⣟⣿⡇⢸⣿⣿⢿⡇⠈⠀⣿⣿⡄⠀⠀⠙⣷⡀⠈⠀⠀⠀⠈⢀⣀⠀⠀⢠⠐⠃⠚⠀⠀⠀⠔⢈⠀⠀⠒",
+    "⠿⠇⠘⣿⡘⢿⣯⡿⣟⣯⣿⢾⡿⣽⢣⢸⣿⢁⣾⣿⣿⣿⣿⣿⣿⣧⠆⠀⣿⣿⣾⣷⣆⢈⡿⣞⣟⣷⡄⠀⠀⠘⣷⠸⣿⣯⡇⢸⣿⣯⣿⡇⢸⠀⢹⣿⣿⡀⠀⠀⠈⢻⣄⠀⠂⠈⠀⠘⢽⠀⠀⠠⢉⢦⠰⠀⡀⠄⣀⠨⠀⠀⠀",
+    "⠀⣴⣧⠘⣿⡌⢿⣟⣿⢯⣿⣟⡿⣝⠆⡿⠃⣼⣿⣿⣿⣿⣿⣿⣿⣿⣸⠈⣿⣿⣿⣿⡿⠀⠹⣯⣛⣯⡆⢸⣯⣄⠙⠀⣿⣟⡇⣾⣿⣽⡿⡇⠘⠁⠀⠻⣿⡇⠀⠀⠄⠀⠹⣆⠀⠀⠀⠀⠈⠜⠁⠀⠨⠠⢉⠔⡁⠊⠄⡘⠀⠀⠈",
+    "⠀⢻⣿⣧⡘⣧⠆⢻⣯⣿⣻⣾⢿⡱⢲⢃⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⣿⣿⣷⡀⠀⠀⣶⣌⡙⠓⢂⣼⣿⠟⣀⡅⢻⣿⠀⣿⣽⣾⣿⠃⠀⣀⣀⣰⣿⡇⢰⠀⠀⠀⡀⠈⢧⡀⠀⠀⠀⠀⠀⠀⠀⠁⢂⠐⠠⢁⠂⠄⠐⠀⠀",
+    "⡩⠀⢿⣿⣷⡈⢟⡄⢹⡿⣽⣛⣮⠃⢡⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣄⠸⣿⣿⣿⣿⣿⡿⢋⣼⣿⡇⢸⡇⢰⣿⣯⣷⣿⠀⠀⢿⣿⣿⣿⠆⠈⢱⠀⠀⢀⠀⠈⠳⡀⠀⠀⠃⠀⠐⠱⠚⠲⠞⠳⠦⠈⠀⠀⠀⠤",
+    "⡱⢁⠘⣿⣿⣿⡄⠙⠄⡉⢻⡿⣅⠀⢺⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⠻⢿⣷⣌⠻⠿⠟⣫⣴⣿⣿⣿⡇⢸⠃⠈⣿⣽⣷⡇⠀⠀⢸⣿⡾⠟⠀⠀⠈⢆⠀⠀⠀⠄⠀⠱⡄⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⣱⠩⡀⠸⣿⡍⠀⣀⠀⠀⠈⢻⠖⠀⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣶⣶⣾⣿⣿⣿⣿⣿⣿⠇⡛⡰⢈⣿⣻⣾⠁⠀⠀⠉⠁⠀⠀⠀⠀⠀⠈⠆⠀⠀⠀⠀⠀⠘⢆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⣇⠣⠜⡀⢠⡅⠀⣿⣷⡄⢀⢀⢇⣦⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠂⢁⡏⢸⣟⡞⡟⠀⠀⠀⠀⠀⠀⢀⣀⣤⣶⣾⣿⣿⣿⣶⣤⡀⠀⠈⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠸⣹⡐⠡⠀⢠⠀⣿⣿⠿⠆⠀⢞⡦⢯⠐⣦⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣸⡇⣸⢯⡿⠁⠀⠀⠀⢀⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠀⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠑⢌⣃⠂⠀⠣⣹⣿⣦⠀⠀⣦⡈⠃⠀⡁⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⣰⣿⠃⣼⢯⠓⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀⠡⠀⠀⠀⠠⡄⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢍⡀⠀⠙⢟⣿⣷⣄⠻⣿⡿⠃⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⣯⡜⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠄⠀⠀⠡⣤⣬⣥⣤⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠠⢘⠶⠁⠀⠀⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⡠⠁⠬⠁⠀⠀⠀⠀⠀⠀⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠁⢂⠐⡀⠄",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠁⡴⠋⠀⠁⠀⠀⠀⠀⢰⡇⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠆",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡁⠉⢙⣿⣿⣿⣿⣿⣿⣿⣿⠟⠠⠮⠁⠀⠀⠀⠀⠀⠀⠀⣾⣷⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣶⣯⣿⣿⣿⣿⣿⣿⠟⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⡇⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⣠⣾⠀⢂⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⢂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠿⠿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⣿⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⣰⣿⣿⠄⠡⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠲⠖⠢⠀⢌⡉⠙⠛⠛⠛⠛⠛⣁⠤⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⢀⣼⣿⣿⣿⣿⣿⣇⠀⠀⠸⣿⣿⣿⣿⣿⣿⣿⡿⠁⢸⡿⣿⣿⠀⠈⠡⠀⠀⠰⢄⠢⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢸⡏⢹⣷⠀⢀⠀⠀⢎⣱⢹⡸⢈⡹⡎⣀⠀⠀⢀⠀⠀⠀⠀⢀⣿⡿⣿⣏⣿⣹⣏⣿⠀⠀⠀⢿⣷⣿⣹⣿⣹⡿⠁⣶⠈⢸⢷⡏⢀⠀⠁⠀⠀⢾⣆⢉⡆⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠸⣤⡑⢨⢇⠲⡩⢆⡣⢄⡀⢂⡀⣠⣼⢿⡷⡿⣯⣟⣷⣻⢯⡿⡇⠀⠀⠸⣧⢿⣽⣾⠏⢁⣾⣻⠀⢈⠻⠀⣞⣧⢦⡄⢸⠢⠁⠀⠈⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⢀⠡⢈⠡⠒⠀⠀⠐⢻⠳⢮⡶⣜⢦⣣⡤⣤⣤⠟⣗⣏⡾⣵⣻⣞⣞⣳⢯⣟⢳⣇⠀⠄⠀⢷⣋⣷⣋⢤⡟⣾⢝⠂⠠⠀⢘⡳⣬⠞⣅⠘⠂⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠁⠂⠄⢃⠢⢑⢂⡀⠀⠈⣟⡱⣚⢬⠗⣣⠝⣦⢫⠞⡭⣞⡱⢧⡳⣍⢾⡱⣞⢎⣧⢳⠀⠀⠀⢈⠵⣣⢟⢮⢽⡸⠋⠀⢰⣙⠀⢹⣊⠽⣜⠲⡄⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⢁⠘⡨⠄⡊⠔⡂⡔⠀⠀⢎⠱⣘⠪⡹⢡⠛⠴⠋⡞⣱⢣⡝⢬⡓⡭⢎⡵⣌⢏⠶⣩⠇⢈⢠⠈⡞⡵⢎⡳⢎⡑⠁⠀⡸⣜⠀⢠⠓⠞⡬⡱⡈⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⢂⠡⢂⠥⡉⢔⡈⠆⢀⠀⠈⠄⠣⢡⢃⠹⡈⠣⠜⢂⢣⠚⡥⡱⡙⡜⢦⡙⢎⡱⢃⠆⠈⠀⠀⡜⡱⢎⡕⠊⢀⠌⠀⠰⡘⡄⠀⢐⠎⢥⠓⡡⠂⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠰⢁⠂⠀⠀⠀⠀⠠⢀⠀⠁⠂⠜⢠⢃⡌⠀⢂⠄⠀⠀⠀⠊⠐⠨⠁⡜⠈⠢⢁⠢⠡⢱⠘⠤⣉⠦⠱⣉⠆⠀⠀⠀⡸⢑⢎⠈⠠⠌⠀⠀⢒⠱⡘⠄⠈⡜⢢⠉⠔⠁⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠀⠀⠀⠀⠀⠐⠀⡀⢂⠐⠠⡀⠄⡀⠈⠂⠈⠘⡄⢣⢁⡀⠠⠐⠂⠀⠀⠁⠂⠀⠃⠂⠁⠂⠐⠄⠃⠐⠂⠀⠀⠀⠡⠋⠀⠌⠂⠀⠀⡈⠆⢂⠱⠀⡈⠔⢂⠉⡄⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠀⠈⠄⠐⠈⠄⡁⢂⠐⢀⠈⠐⠤⢈⠱⠀⡔⠠⡀⠄⡀⣀⠂⠡⠌⢂⠡⠒⠰⡀⠄⡀⢀⠠⢀⢂⠉⠀⠀⢀⠂⡘⠠⡁⠀⡐⠈⠔⡈⠰⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠄⠂⠁⠠⠈⠐⠠⠀⠄⡀⠂⡀⠄⡀⢀⠀⠁⠐⠁⠐⠈⠐⡀⠌⠡⠘⠠⢁⠊⠡⠐⡡⠈⠄⢂⠁⠂⠀⠀⠀⠂⠐⠁⠂⠀⠐⢀⠁⠂⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⡈⢀⠡⠀⠀⢁⠀⠂⠐⠀⠂⠁⢀⠂⠐⢤⠄⡀⠈⠠⠁⠂⠄⡈⠄⠁⡀⠁⠀⠂⠀⠀⠀⠀⠀⠄⠀⠀⡀⠐⠈⠀⠠⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_17[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣴⢿⠶⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠛⠁⠀⢸⣶⠀⣿⣂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠖⠋⠁⠀⠀⠀⠀⠀⣘⡷⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠞⠋⠀⠀⠀⠀⠀⠀⣀⡴⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠖⠋⠀⠀⠀⠀⠀⠀⣠⡴⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⢀⣠⠖⠋⠀⠀⠀⠀⠀⠀⣤⣴⣛⣁⣀⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣧⣄⠀⠀⠀⠀⢀⡴⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠈⠉⠉⠉⠉⠉⠉⠙⠛⠓⠒⠶⠦⢤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢳⡈⠙⠲⣤⡞⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⢦⣹⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⣴⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⡴⣴⠴⣴⢤⣴⢤⣤⣤⣤⣤⣤⣄⣀⣀⣀⣹⣼⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠁⠀⠀⠀⠀⠀⠀⢀⣤⠖⠛⠛⠚⠒⠒⠦⠶⠤⠤⠴⠤⠴⠒⠒⠒⠲⠤⢤⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⠀⢀⣠⠴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⠢⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠉⠀⠀⠀⠀⠀⠀⢀⣶⣿⣷⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠷⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⠀⣠⠶⠋⠁⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣌⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⣀⣴⠚⠉⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠈⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⢀⣠⠾⣿⣾⡇⠀⠀⢀⡼⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣼⡶⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠙⣆⠀⠀⠀⠀⠀⠹⣄⠀⢀⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣰⠏⠀⠀⠀⠀⣠⣴⣿⢷⣿⠟⠃⠀⠀⢀⣾⠁⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⣹⠃⠀⠀⠀⠀⠀⠀⠀⣾⡇⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⠸⣄⡞⢁⣬⠙⢳⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⡟⠛⣲⡞⠁⠀⠀⢀⣠⡾⠛⠉⣠⡟⠃⠀⠀⠀⢠⡞⠁⠀⠘⢦⡀⠀⠀⠀⢀⡼⠁⢰⠇⠀⠀⠀⠀⠀⠀⠀⣸⠛⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣆⠀⠀⠀⠀⢀⡟⢀⣾⠏⣠⠻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⡟⠀⢹⣾⠃⠀⠀⣀⣴⡟⠛⢶⣶⡾⠃⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠈⢳⡄⠀⣰⠏⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⢀⡏⠀⢹⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⣻⡄⠀⠀⠀⡞⢀⣾⡟⢠⠃⢘⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡏⠉⣷⠀⠀⣙⣿⠶⠾⢿⣵⡙⣧⢰⡟⠁⠀⠀⠀⠀⠀⡼⠁⠀⠀⠀⠀⠀⠀⢹⣞⡃⠀⠀⠀⡿⠀⠀⠀⠀⠀⠀⠀⣾⠁⠀⠀⢷⡀⠀⠀⠀⣀⣤⠾⠂⠀⠚⣧⠀⠀⡼⢁⣾⡟⣰⠓⠒⠒⠿⢶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣸⣇⠀⠈⠷⣤⡟⠁⠀⠀⠀⠉⠐⣿⡞⠀⠀⠀⣠⡦⠀⢰⠇⠀⠀⠀⠀⠀⠀⢠⡞⠙⢧⡀⠀⢰⡇⠀⠀⠀⠀⠀⠀⢠⡏⠀⠀⠀⠘⣧⣠⠴⠚⠉⠀⠀⠀⠀⠀⣿⠀⣰⠃⣾⡟⣲⠃⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡏⠙⣦⡀⢰⡟⠀⠀⢀⡄⠀⠀⢸⡿⠀⢀⣰⡎⢹⠁⠀⢾⠀⠀⠀⠐⠻⣤⣠⠟⠀⠀⠈⠻⠄⠺⣇⠀⠀⠀⠀⠀⠀⣾⠁⢀⣠⡴⠛⢻⡄⠀⠀⠀⠀⠀⠀⠀⠀⣿⣧⡇⣾⣿⣿⠃⠀⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⡿⣄⠀⠙⢻⠀⠀⢀⣾⠁⠀⠀⣼⠇⣠⣿⠁⠀⡟⠀⢀⡟⠀⠀⠀⠀⠀⢠⠟⠳⢦⣀⠀⠀⠀⠀⡿⠀⠀⠀⠀⠀⠲⣿⠴⠋⠀⠀⠀⠀⣷⠀⡄⠀⠀⠀⠀⠀⢀⣿⣯⣇⢾⢇⣿⠄⠀⠀⠀⠀⠀⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⣧⡈⠙⠒⠾⣦⣲⡾⠁⠀⠀⢀⣿⣴⢛⡟⠀⢸⠃⠀⢐⡗⠀⠀⠀⠀⢠⠟⠀⠀⠀⠈⠓⠦⣄⣀⣿⣀⠀⠀⠀⠀⢠⡏⠀⠀⠀⢀⣀⡤⢾⡟⠃⠀⠀⠀⠀⠀⢨⡇⢸⣼⣿⣿⡟⠀⠀⠀⠀⠀⢰⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠊⠻⠦⣤⣴⠟⠂⠀⠀⠀⠀⢘⣿⢁⣰⠃⠀⢸⠀⠀⢸⠄⠀⠀⠀⢀⡞⠀⠀⠀⣀⣤⠴⠚⠋⠀⠹⡇⠀⠀⠀⠀⣼⣤⡤⠖⠛⠉⠀⠀⠀⣇⠀⠀⠀⠀⠀⠀⣸⣷⢼⠘⣿⣿⡄⠀⠀⠀⠀⠀⠰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⠁⠀⠀⢰⡞⢹⣦⡀⠀⠀⣠⡀⢸⠏⣲⡏⠀⠀⣻⠀⠀⣸⡅⠀⠀⢠⣾⣠⠴⠖⠋⠁⠀⠀⠀⠀⠀⠀⠻⡅⠀⠀⢀⡏⠉⠓⠦⣄⡀⠀⠀⠀⣿⣄⠀⠀⠀⠀⠀⣿⡋⠻⣦⣟⣻⠁⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣸⠃⠀⠀⢰⠟⠀⢸⠂⡏⠉⠙⠻⢤⡟⣲⡟⠀⠀⠀⣧⠀⣼⠛⡇⠀⠀⡾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⡄⠀⣼⠃⠀⠀⠀⠀⠉⠓⢦⣀⣺⡆⠀⠀⠀⠀⠀⣾⣥⡀⣸⡿⡟⠀⠀⠀⠀⠀⠀⢸⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢠⡏⠀⠀⣰⢟⠀⠀⣸⠀⡇⠀⠀⢠⡞⢒⡿⠁⠀⠀⠀⣻⣴⠓⠚⣧⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀⣼⠶⢤⣄⣀⡀⣀⠹⣄⡏⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⣷⠤⠀⠀⠀⠀⣧⣾⡟⡟⠠⡇⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⣾⠀⠀⣰⠏⠂⠀⢰⣿⠀⣧⣠⠶⠋⢀⣼⠁⠀⠀⠀⠀⠘⠏⠀⠀⢿⡀⡿⢷⠀⠀⠀⠀⠀⠀⣸⠳⠀⠀⠀⠀⠉⠉⠉⠉⠉⠉⠉⠳⡄⠀⠀⠀⠀⠀⠀⣿⡂⠀⠀⠀⣸⣿⡿⢠⠃⠐⡇⠀⠀⠀⠀⠀⠀⢸⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠸⢷⣄⣰⠋⠀⠀⠀⢸⣿⠀⠈⠁⢀⣰⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣇⠘⢷⣄⠀⠀⠀⢰⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡆⠀⠀⠀⠀⢸⢟⡇⠀⠀⢀⣿⣿⠁⡎⠀⢠⡇⠀⠀⠀⠀⠀⠀⢸⡂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠀⠀⠀⠀⠘⠻⡦⢶⣾⣏⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢧⠀⠀⡟⠳⢤⣀⢸⡃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⠀⠀⠀⠀⣾⠀⣧⠀⠀⣸⣿⣟⣺⠃⠀⢸⡇⠀⠀⠀⠀⠀⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢙⡟⠒⠒⠢⠤⢤⣄⣀⣀⠀⠀⠀⠈⢧⡀⡇⠀⠀⣽⠛⠿⢤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣆⣀⣠⣴⡏⠀⣿⠀⢀⡟⠚⠛⠁⠀⠀⢼⡇⠀⠀⠀⠀⠀⠀⢸⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠞⡇⠀⠀⠀⠀⠀⠀⠀⢈⡟⠑⠒⠤⣄⣿⣧⢀⣴⡋⠀⠀⠀⣨⣿⡏⠛⣟⠒⣿⠚⢺⡿⠶⣾⡛⠛⠉⠉⠀⡾⢀⣾⢻⡀⡿⠁⠀⠀⠀⠀⠀⠘⡇⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠏⢠⡟⠀⠀⠀⠀⠀⠀⠀⣸⠁⠀⠀⠀⠀⠙⠻⠛⠁⠉⠙⠒⢦⡟⠀⠻⣤⣿⣿⣅⢲⡿⠉⣄⡏⠙⣆⠀⠀⣾⠟⠋⠀⢾⡿⠁⠀⠀⠀⠀⠀⠀⢸⡧⠀⠀⠀⠀⠀⠀⠰⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠁⠀⡾⠀⠀⠀⠀⠀⠀⠀⢠⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⢀⡟⢶⡏⠙⠁⠀⣾⣣⡀⠘⣧⣴⣃⠀⠀⠀⠙⠁⠀⠀⠀⠀⠀⠀⠀⠰⣿⠀⠀⠀⠀⠀⠀⠐⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⡼⠁⠀⠀⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⣸⠁⣸⡇⠀⠀⠀⠻⣿⢷⣀⣸⡄⢹⡍⠙⠋⠛⠲⡖⢦⡀⠀⠀⠀⠀⠀⢸⡄⠀⠀⠀⠀⠀⠀⢻⠛⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠴⠋⠀⠀⢀⡴⠁⠀⠀⠀⠀⠀⠀⠀⡼⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣴⡖⣿⡇⠀⢠⡏⠀⠻⡃⠀⠀⠀⣶⣏⣨⣿⣿⣹⠟⠀⠀⠀⠀⠀⣧⠀⣷⠀⠀⠀⠀⠀⠀⣇⠀⠀⠀⠀⠀⠀⠘⡆⠈⠧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⣀⡶⠏⠀⠀⠀⠀⢰⡾⠀⠀⠀⠀⠀⠀⠀⠀⣸⠁⠀⠀⠀⠀⠀⠀⠀⠀⢸⡿⢿⣶⣸⡷⠈⡇⠀⣾⠀⠀⢸⡇⠀⠀⢾⡏⢿⣿⣿⣇⠀⠀⠀⠀⠀⠀⠀⡿⠀⡿⢿⡀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⣿⡀⠀⠉⢆⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠈⢿⡁⠋⠚⠋⠉⠁⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⣰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⡿⠋⠀⠀⠙⣦⡏⠀⠀⢸⡇⠀⣴⡾⠀⢺⡿⢿⣭⣧⡀⠀⠀⠀⢀⡴⠃⣼⢃⡿⠁⠀⠀⠀⠀⠺⡅⠀⠀⠀⠀⠀⠀⠈⠁⠀⠀⠀⠉⠲⢄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠉⠓⠒⠢⠆⢶⡦⠶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣄⢣⣷⡄⠀⠀⠀⡾⠀⠀⠀⢸⡟⠛⠉⠀⠀⠈⢳⣼⠀⡿⢿⡖⠒⠚⠉⢀⣴⠷⠚⠁⠀⠀⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠓⠒⠦⠤⠤⢦⣴⡶⠞⠃⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡾⢧⢻⣆⣀⣼⠇⠀⠀⠀⢸⣇⠀⠀⠀⢀⣠⢾⡟⣿⠃⠀⠙⠒⠒⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣦⣤⣴⠒⠋⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⡤⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣤⣿⢯⡁⢻⠀⠀⠀⠀⣸⢿⠦⣄⣰⣏⣠⣟⡴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠓⠲⠤⠤⢄⣀⣀⡀⠀",
+    "⠀⠀⠀⠀⣠⠔⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡼⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⣤⣉⠚⣆⠀⠀⣠⣿⣼⣤⠜⢛⣹⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡽⠃",
+    "⠐⢶⡚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠖⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡷⢌⣉⢻⣷⣴⠿⠻⣿⣖⢻⡏⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠀⠀",
+    "⠀⠀⠉⠓⠦⢄⣀⡀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠊⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣧⠀⠀⠈⡇⠉⠀⢠⡏⠀⢹⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡤⠚⠁⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠉⠉⠃⠙⠋⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⡆⠀⠀⡇⠀⠀⠸⣧⣴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⢄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠚⠁⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧⠀⠀⣿⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠛⠒⠒⠃⠛⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣷⣙⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_18[] = {
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣴⣦⣶⣤⣤⣀⣀⣤⣤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣾⠿⠿⣶⣦⣄⡀⠀⢀⣠⣴⣶⠿⠿⠛⠋⠉⠉⠉⠉⠀⠀⠈⠉⠛⠋⠉⠉⠙⠻⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⠏⠀⣠⣄⡀⠈⠙⣿⡾⠟⠋⠁⢀⣀⡤⠶⠖⠛⠛⠲⠞⠋⠉⠛⠛⠒⠲⢿⣷⣦⣄⠀⠉⠻⣷⣶⣤⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⣶⡶⠾⠾⠿⠃⢀⣼⣿⣻⣿⡏⠀⠉⣀⣤⠶⠞⠉⢁⠠⠀⠄⡒⠀⠄⠂⠌⢀⠡⠐⠀⠀⠀⠈⠙⢿⣿⣦⣀⠀⠀⠈⠙⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⡿⠟⠃⠀⣀⣀⡀⠀⠀⣼⡿⣧⣿⣿⠇⢀⡼⠛⠀⠀⡀⠘⢀⠀⠄⢠⠃⠠⢀⠘⠀⠄⠀⠄⡀⠀⠀⠀⠀⠀⠸⢿⣿⣧⡀⠛⢧⡀⠘⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⠋⠀⡠⠞⠋⠀⠀⠀⢀⣾⣿⣽⣿⣿⡿⣿⠋⠀⠄⠂⢁⠠⠈⡀⠄⢈⡏⢀⠐⠠⠀⡁⠂⢁⠠⠀⠀⠀⠀⢀⠀⡀⠈⠹⣟⣿⣦⠀⢻⡄⠈⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⣠⠞⠀⡀⠀⠀⠀⠀⣾⣿⣳⣿⡿⢃⡾⠁⠀⠀⠂⢈⠀⢄⠞⠀⡐⣘⠀⠄⠂⠠⠁⡀⠌⠀⠀⠀⠀⠀⠀⠀⠁⠀⠐⡀⠙⣿⣿⠀⡀⢿⠀⠈⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⢰⢏⣾⣿⣶⣎⣠⣤⣼⣿⣿⣿⡿⠁⣼⠃⠀⠀⠀⠀⠀⣀⡞⠀⡐⠀⣷⠀⠀⢈⠀⠐⠀⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢂⠠⠀⠸⡟⢀⠐⣸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⠃⢀⣿⣾⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢃⢰⡇⠀⠀⠀⠀⠀⠀⡼⠀⠀⠄⠂⣽⣄⠀⠀⠀⢀⠀⠙⠧⣄⠀⠠⠀⠄⢀⠠⠐⠀⡀⢧⡐⠀⢂⠰⢸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣄⣀⣼⡟⠀⣸⣟⣿⣽⣿⣟⠻⢿⣿⣼⣿⣿⣿⢊⣼⢡⠀⠀⠀⠀⠀⣸⠇⠀⠀⠐⢀⡇⠸⣦⡀⢈⠀⠀⠀⣇⠈⠛⣦⣐⠈⠀⠄⠂⡐⠀⡀⢧⠐⡀⢎⣹⠇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⠿⡷⡟⠿⢋⠿⢿⡿⠛⠀⢀⣼⠟⢸⣿⣿⢥⡟⣿⠀⠀⠀⠀⣰⠏⠀⡀⠄⠀⣸⠁⠀⡼⣿⣦⡀⠡⠀⠹⡄⠀⠀⠽⢷⣌⠀⠂⠄⠂⡀⠘⡄⠸⣄⢻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣧⣛⠴⣩⠝⡊⠅⠀⠀⠀⣠⣿⠟⠀⣼⣿⣿⡎⣽⣿⠀⠀⠠⣱⠏⠀⢂⢠⠀⢠⣿⣀⡀⠀⠜⣿⣷⣦⡐⠀⢻⡄⠀⠀⣹⣿⣷⣅⠐⠠⢀⠁⡸⢐⠬⣻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⣠⣶⡿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠗⡌⠀⠀⠀⣠⣾⣿⠋⠀⢸⡇⠀⢸⣷⣾⣿⠇⠀⢡⡟⠀⠌⠀⡎⠀⣼⠋⠈⠉⠓⠲⢿⣿⣿⣿⣄⠈⣧⠀⠚⠁⠺⣹⢿⣷⡆⡄⢂⡘⡇⢎⣽⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣭⣛⢩⠁⠀⠀⠀⣠⣾⣿⡟⠁⠀⣰⣾⡇⠀⠈⣿⣿⣿⠁⢨⡿⠁⠐⠠⢁⡇⢐⣿⠀⠀⣄⠀⠀⠈⢻⣿⣿⣿⣇⢾⡇⠀⠀⣀⣼⣿⣿⣿⣷⢆⡜⣹⢂⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⢿⣿⣷⣄⠀⢀⣴⣿⡿⠋⠀⣰⣴⣿⣿⣻⡶⢤⣼⣿⡿⢀⣿⠃⢀⠁⠂⢸⣧⢨⣿⣿⣶⣦⣄⠀⠀⠀⠻⣿⣿⣿⣿⡇⢠⣾⣿⣿⡽⢿⣿⣿⣿⡜⣳⠐⣾⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣟⣛⠻⢿⣷⣝⢿⣿⣧⣾⣿⠟⠁⠀⠀⣿⣿⣿⣋⣼⣷⡛⡟⠿⣿⣼⣟⠀⠤⠈⢀⣿⣿⣸⣿⣿⡟⣻⠝⢧⠀⠀⠀⠈⠻⣿⣿⢷⣿⣿⣿⣼⡇⠈⣿⣿⣿⣞⠱⠈⣾⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢸⣿⣿⣿⣿⣿⢿⣿⣿⣿⣿⣿⣷⣤⠙⣿⣧⢿⣿⣿⠃⠀⡀⠀⠀⣿⡟⣿⣧⣿⣿⣿⣼⢲⡌⡽⣿⣤⠀⢂⢰⣿⣿⣿⠿⡿⠛⣿⠄⠀⠀⠀⠀⠀⠀⠈⠹⠎⢯⣙⠉⣸⠃⠸⢫⣿⣿⣯⠆⠁⢾⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢸⣿⣿⣿⣿⡏⣼⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣾⣿⡇⠀⠠⠆⣠⣼⣿⢀⣿⣿⣿⣿⣿⣿⣿⣼⠡⠎⠻⣿⣤⣼⡗⠻⠻⠦⣤⠴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⠛⠁⠀⠀⣾⠘⣿⠛⡇⢈⢚⡇⠀⢸⣯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢸⣿⣿⣿⣿⡅⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⡇⠀⢸⣿⣿⢿⣧⣼⣿⣿⣿⣿⣿⣿⣿⣿⣧⠉⠋⠙⠙⢻⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⡁⠠⠁⠂⡸⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⢸⣿⣿⡽⣿⣧⠹⣿⣿⣿⣿⣿⣿⣿⠏⣼⣿⣽⣿⡇⣰⠏⢸⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⡿⢛⠷⠈⠀⠀⠀⠀⠹⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⢤⣿⡇⠐⠀⡁⠄⢁⠰⣿⠀⠈⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠘⢿⣿⣿⣿⣿⣷⣬⣙⡛⠿⣻⣿⣫⣾⣿⣏⣿⣿⡶⠋⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠃⠀⠀⠀⠀⠀⠀⢠⣿⣟⣳⣄⠀⠀⠀⠀⠀⠠⣴⣶⣶⣶⣾⠗⠀⠀⠀⣴⣿⣿⣿⠀⠂⠠⠐⢀⠐⣿⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠻⣿⣼⣿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢿⠏⠀⣴⢿⡝⠁⠈⠉⠙⢿⣿⣿⣿⣿⣟⠀⠀⠀⠀⠀⠀⠀⣀⣼⣯⣿⡟⠻⣷⣄⡀⠀⠀⠀⠈⠉⠉⠉⠁⠀⢀⣴⣾⣿⣿⣿⣿⡇⠀⡁⠐⡀⠂⣽⡇⠀⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠐⣿⡧⣿⡿⢿⣻⣯⡿⣿⣯⣿⣾⢧⡟⠃⢠⣼⡟⡎⠀⠉⠉⠙⠛⠳⡞⣿⣿⣿⡇⠀⢀⣤⣤⣀⠀⣴⣿⡿⠟⠉⠙⢦⣽⣿⠿⢦⣤⣀⠀⠀⠀⠀⣰⠛⢻⣿⣿⣿⣿⣿⣿⣷⠀⠄⢁⠠⠐⡸⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣿⣷⣉⣿⣿⣿⣿⣿⣶⡝⣷⢿⣾⠃⣠⣾⣿⢇⡟⢀⡀⠐⠀⠀⠀⣇⢸⣿⣿⠇⠐⠋⠀⠀⢘⣿⡿⠋⠀⣠⡆⠀⣾⡟⣿⣿⣾⣿⣿⣿⣷⣾⣿⢿⡇⢸⣿⣿⣿⣿⣿⣿⡿⠀⢈⠀⠄⠂⠱⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣿⣿⣿⣟⣿⣿⣿⣿⣿⣿⢸⣿⣿⢠⣿⣿⣿⢸⣷⡸⢿⣦⣄⠀⣰⣇⣾⣿⣿⠂⠈⡀⠀⠀⣸⠋⠀⣠⣾⠟⠀⢠⡟⠻⠿⠛⠋⠀⠉⠉⠙⠿⠿⣦⡁⢿⣿⣿⣿⣿⣿⣿⡇⠀⢂⠀⠂⠌⠐⣿⠀⠘⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⣽⣿⣿⣿⢹⣿⣿⣿⣿⡿⣸⣿⣏⣾⣿⣿⡯⣾⡿⠷⢮⣽⣿⣶⣿⠿⠻⡉⠟⣶⣀⠑⠤⠀⡿⠲⣶⡿⠋⠀⣀⠾⠁⠀⠀⠀⠀⠀⠀⠀⢰⡤⠴⠟⢧⡌⠻⢿⣿⣿⣿⣿⠃⠀⠌⠐⡀⠄⠐⣻⡀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠠⣿⣿⣯⠻⣷⣍⣛⣛⢻⣴⣿⠟⣱⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠠⣅⣜⠠⠙⣿⣶⣄⣼⢧⡀⠈⠀⣀⣾⣟⣓⠂⠄⠀⠀⠀⠀⠀⠀⠘⠷⣤⣀⢨⡿⢷⣤⡈⠛⠛⠉⠋⠻⠶⣶⣦⣄⠂⢹⡇⠀⢿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢻⣿⣿⣷⣮⣙⡛⢛⢻⣻⣥⣿⣿⣿⣿⠟⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⣠⣿⣿⣿⣿⡄⠙⣄⠚⠉⠁⠀⠉⠙⣆⠈⠐⠠⠀⠀⠀⠀⠀⠈⢷⡄⠘⢦⡉⠉⠳⢦⡙⢦⠀⠀⠀⠉⠺⡛⢶⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢁⠠⢠⠀⡄⢠⠀⠠⢀⠀⠀⠀⠀⠀⢀⡞⠙⣿⣿⣿⣿⡄⠹⡆⠀⠀⠀⠀⠀⢯⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡄⢀⠳⣤⠀⠀⠁⠈⠳⡀⠀⠀⠀⠈⢢⡻⡄⠸⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣤⢃⠦⣡⠒⠤⠘⠠⠀⠀⠀⠀⣀⣤⠟⠁⢸⣿⣿⣿⣿⣿⡀⢹⡄⠀⠀⠀⠀⠩⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣆⠀⡈⠳⣄⠀⠀⠀⠙⢦⡀⡀⠀⠀⠙⣇⠀⠈⢻⡿⢿⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⠿⠶⠿⠾⠷⠷⠶⠾⠟⠛⠉⠁⠀⡘⣿⣿⣿⣿⣿⣿⡇⠘⣧⠀⠀⠀⠀⢸⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣧⡀⠐⠘⢷⣄⠉⠦⠿⣇⠁⠀⠀⠀⠈⠳⢦⣀⣧⡀⠈⠻⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡼⢅⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⣼⣿⣿⣿⣿⣿⣿⡿⢀⣿⠀⠀⠀⠀⢠⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣷⡈⢀⠂⠙⢿⡶⠶⠿⠶⢦⡀⠀⠀⠀⠀⠀⠙⣿⣦⠀⠙⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠰⢠⢂⠠⢀⡀⠀⠀⠀⠀⠀⢀⣡⣿⣿⣿⣿⣿⣿⣿⡇⢸⡇⠀⠀⠀⠀⢸⡇⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡆⠠⠁⡈⠱⡆⠀⠀⠲⣕⡀⠀⠀⠀⠀⢀⡟⣿⣷⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢦⡙⡆⢬⡑⢢⠠⣉⣄⣠⡴⠞⠋⣿⣿⣿⣿⣿⣿⣿⡟⠀⡾⠀⠀⠀⠀⠀⣼⠄⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⡀⠐⡀⠁⠹⡄⠀⠀⠘⢿⡄⠀⠀⣠⡾⢁⣿⣿⣿⣦⡀⠨⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⠛⣿⣿⣿⣿⡟⡟⠛⠛⠛⠿⠛⠿⠛⠛⠟⠛⠉⠁⠠⣄⣾⣿⣿⣿⣿⣿⣿⡟⠁⣼⠁⠀⠀⠀⠀⢸⡏⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠠⢀⠁⠂⢿⠀⠀⠀⠀⣿⣦⡾⢋⣴⣿⣿⣿⣿⣿⣿⣦⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀⣘⣿⣿⣿⣿⡱⠡⠌⢂⣄⡀⠀⠄⢂⡀⠀⠀⠄⣱⣾⣿⣿⣿⣿⣿⡿⠋⣠⢾⡇⠀⠀⠀⠀⢠⣞⢁⣸⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠈⠄⡘⣇⠀⠀⠀⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠈⢻⣧⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⢸⡏⠀⢹⣿⣿⣿⣿⣇⠻⣌⠲⣌⠷⢬⠐⠠⢀⠂⣀⣴⣿⣿⣿⣿⠿⠛⢁⣤⠞⠁⠈⣿⣄⠀⠀⢀⣾⠇⣼⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠡⠀⠄⢿⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠈⣿⡆⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⡿⠈⠻⣿⡿⢿⢷⣾⣿⣾⣽⣦⣭⣶⠟⠛⠛⠛⠛⢉⣉⣠⡴⠞⠋⠀⣠⣶⡀⠘⢿⣦⣶⡿⠋⠚⠛⠓⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⡗⠠⠐⠀⠡⠀⢼⡆⠀⠀⢹⣿⡏⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⢰⣿⠀⢰⡇⠠⢀⠀⢀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣾⠛⠛⠉⠁⣀⣤⣶⠿⠛⠻⣿⡀⠸⣿⡿⡖⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⢀⠂⢁⠂⢁⠀⣧⠀⠀⠸⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⣼⡏⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⣸⡏⠀⣸⠀⠠⠀⠌⠀⠠⠈⢀⠐⠀⠂⠀⠈⠉⢉⣿⣿⣿⠀⢰⣾⠿⠛⠉⠀⠀⠀⠀⢿⣧⠀⢸⣷⣷⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣇⠀⡐⠠⠐⠀⢂⢻⠀⠀⢸⣿⣿⣿⠟⣻⣿⣿⣿⣻⡟⣿⣿⡟⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⣿⠀⡀⢁⠂⠈⠀⠄⠂⠀⠌⠀⠁⠀⠀⣾⣿⣿⣿⠀⠈⣿⠄⠀⠀⠀⠀⠀⠀⠩⣿⣆⠀⢻⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠠⠐⡀⠡⢀⢸⡆⠀⢸⣿⣿⣥⣿⣿⣿⣿⣿⣿⡿⠈⣿⠀⢠⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⢀⣿⠀⢰⡇⠀⠄⡀⠂⢁⠀⠂⢀⠐⠀⣈⣤⣄⣾⣿⣿⣿⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠸⣿⡄⠈⢿⣧⠤⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠡⠐⢀⠐⡀⠈⣷⠀⢸⣿⣿⣿⣿⣿⣿⣿⡿⡿⠁⣰⠇⠀⣾⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⣸⡟⠀⢸⠃⢀⠂⠠⠐⠀⡀⠌⠀⠀⠄⣾⣿⣿⣿⢿⣿⣿⣿⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⢻⣷⡀⠘⣿⣆⠀⢀⠠⠐⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡅⠂⢈⠠⠀⠄⡁⠸⡆⢸⣿⣿⣿⣿⣿⣿⡿⢱⣇⣀⡟⠀⣼⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⣿⡇⠀⡿⠀⠠⠀⡁⢀⠂⠀⠠⠐⠈⠀⣿⣿⣿⣯⣿⣿⣿⣿⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣧⠀⢹⣿⡄⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⢂⠠⠈⡀⠄⠁⢿⣻⣿⣿⣿⣿⣿⡿⢠⣟⣼⡿⠁⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢠⣿⠀⢰⡇⠀⡁⠠⠐⠀⠀⠀⠂⠀⠄⣠⣿⣿⣿⣟⣿⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡄⠀⢻⣧⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣻⣇⠈⡀⠄⠂⡀⠂⢁⠘⣿⣿⣿⣿⣿⣿⣥⡟⡴⣼⠃⢀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⢸⣿⠀⢸⡇⠀⡄⠐⢠⠀⠁⠀⡄⣴⣾⣿⣿⣿⣿⣿⢻⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⡄⠈⣿⡆⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⠀⡄⠂⠁⢠⠈⢠⠀⢹⣿⣿⣿⢻⣿⣾⢳⢳⡏⠀⣼⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⢀⣾⡇⠀⣾⣄⣀⣄⣐⣀⣀⣀⣠⣾⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡀⢸⣿⣠⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣧⠀⣹⣿⣤⣀⣀⣀⣀⣀⣀⡀⠀⠀⠀⠀⠀⣀⣀⣸⣿⣀⣠⣔⣈⣤⣐⣀⣈⣀⣈⣹⣿⣿⣾⣷⣏⣾⠁⣠⣿⡃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠈⠀⠈⠁⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠈⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char *mikuart_19[] = {
+    "",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣤⣤⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣷⣷⣷⣷⣆⠀⢀⣀⣀⣀⣀⣀⠀⢠⣾⣿⡟⢻⣿⣷⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣯⣴⡿⣟⠛⡏⢭⢩⡙⡍⣛⠻⣾⣿⣿⣷⢾⣿⡿⡛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⡿⣿⣧⡓⡌⣿⡉⢦⠡⡜⢰⢡⢺⣿⣿⢻⣿⡧⡘⢟⣿⡇⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣟⡛⢼⡏⡔⢢⢱⣿⡜⣂⠓⡬⢑⠦⣿⣿⣿⢒⢤⠓⡘⢆⠲⡹⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⢣⡷⡘⣾⡗⢬⢃⣾⠋⠻⢦⣝⣴⣉⡖⢿⣍⢻⣿⢢⠙⡬⢌⡑⢆⠭⢷⡄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡟⣿⡇⣿⠣⣿⡇⢻⣎⠦⡟⠀⠀⢀⡈⠙⣿⣖⢹⣧⣣⢹⣧⠍⡔⢣⡘⢌⢆⢣⠻⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢏⢲⡟⣸⣿⣡⡿⣺⣆⠹⠻⠇⠠⣾⣻⣿⣽⡿⠽⠷⣿⢦⢩⢹⣾⢈⠦⣑⠪⠌⡆⢣⡙⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠻⣼⢹⡧⣿⣿⢷⣿⣿⠿⠿⣆⠀⠀⠈⠩⡏⠋⠁⠀⠠⢸⡍⣆⠃⣿⣎⠲⢌⡜⠱⣨⠱⡨⢍⢻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⡜⢄⠯⣿⡟⣿⣯⣿⠀⠀⢀⣿⣴⣶⣿⡾⠷⠁⠀⠀⠀⢸⡗⣪⢱⡿⠹⣷⠨⠔⣃⠦⣑⠡⢎⠢⡝⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠣⣍⠰⣊⠜⡘⠿⣘⢷⣽⣇⡀⢈⠛⢿⢿⠟⠀⠀⠀⠀⠀⠀⣸⠗⣼⠿⠁⠀⠹⣧⡙⡔⢢⠥⡙⠤⡓⣌⠹⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠣⣍⠰⢃⠴⢩⡘⠥⡘⣌⣿⠿⣟⠾⣥⣀⣀⢀⣀⣀⣠⡤⠶⠚⢿⠟⠋⠀⠀⠀⠀⠙⣷⡌⢥⠒⣩⠒⡡⠜⢢⡉⣷⡤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⡕⢢⡉⢎⠜⢢⠜⢢⣑⡾⠣⠀⠀⠀⠀⠈⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣆⡹⢄⢣⠱⣉⠦⠱⡘⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢏⠲⠌⡥⢘⠢⢍⡒⡌⣣⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣧⣊⢆⡳⠰⢌⢣⢑⡚⢿⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⣊⠲⢩⠔⡩⠜⢢⢜⣴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠚⢷⡦⣘⠱⣊⠤⠣⢜⡸⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣟⡸⢄⣋⠲⢌⡑⢎⣡⡾⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣦⡓⢤⡙⡘⢆⡒⣹⣧⠀⠀⠀⠀⠀⣠⣦⡀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⣡⠒⡬⢄⡓⠬⡘⣴⡟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢿⣤⢃⠝⡢⢜⡰⢹⡶⢞⡛⠷⢾⣯⡜⣿⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢣⡑⡜⢰⠡⠚⣔⣱⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢾⣰⠑⡆⣎⡱⢛⡗⢎⠞⡠⣿⡐⣿⡄",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡏⣆⠱⡈⠇⡎⢱⣾⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⣿⣰⠇⣇⡉⢸⣈⣶⣿⡏⢱⢸⡇",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⢱⣊⠱⢌⠓⣌⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢻⣶⣤⡽⠟⠋⠁⣼⢋⠦⢹⡇",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣟⠢⣅⢋⠴⢩⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⢮⣎⣻⡇",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠬⡓⢌⡒⢜⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡾⠿⠏⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠳⣌⠱⡊⡔⢳⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣏⠱⣂⢣⠱⡘⢼⠇⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡿⢨⠓⡤⢣⢡⡙⣾⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠧⢃⠭⣐⢃⠦⢹⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡏⡜⣡⠚⠤⣃⢮⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡿⢱⡘⠤⣙⠲⢰⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⠦⢡⠓⡤⢣⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣄⠀⠀⠀⠀⠀⢠⡯⢱⡉⢦⢉⣶⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⣾⣹⣹⡇⠀⠀⠀⠀⣾⣓⠥⢚⠤⣳⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣶⣿⣿⣿⠿⣸⣗⠀⠀⠀⣰⡗⣌⠚⡤⣳⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠟⣫⠰⡘⡄⢛⢿⣦⣠⡿⡖⠬⡘⣶⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣜⠤⣓⠺⢜⣃⣖⣌⠛⡟⢏⢣⣳⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠷⢦⣧⣎⡡⡖⣨⠱⡘⣌⢲⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣶⢅⠲⡡⢆⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠹⣧⣩⠳⣼⠇⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
+    NULL
+};
+
+static char **mikuart[] = {
+    mikuart_0,
+    mikuart_1,
+    mikuart_2,
+    mikuart_3,
+    mikuart_4,
+    mikuart_5,
+    mikuart_6,
+    mikuart_7,
+    mikuart_8,
+    mikuart_9,
+    mikuart_10,
+    mikuart_11,
+    mikuart_12,
+    mikuart_13,
+    mikuart_14,
+    mikuart_15,
+    mikuart_16,
+    mikuart_17,
+    mikuart_18,
+    mikuart_19,
+};
+
+#define migucount (sizeof(mikuart)/sizeof(mikuart[0])) 
+
+#endif
+
diff --git a/src/color.rs b/src/color.rs
deleted file mode 100644
index 74497ab..0000000
--- a/src/color.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-use clap::ValueEnum;
-// No external sysinfo dependency — use environment heuristics instead for Windows shell detection.
-use std::error::Error;
-use std::fmt;
-use std::str::FromStr;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Color {
-    Named(NamedColor),
-    Hex(String),
-    Rgb(u8, u8, u8),
-    Hsl(u16, u8, u8),      // h: 0-360, s: 0-100, l: 0-100
-    Ansi(u8),              // ANSI color code (0-255)
-    Truecolor(u8, u8, u8), // 24-bit RGB
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, ValueEnum)]
-pub enum NamedColor {
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    White,
-    BrightBlack,
-    BrightRed,
-    BrightGreen,
-    BrightYellow,
-    BrightBlue,
-    BrightMagenta,
-    BrightCyan,
-    BrightWhite,
-}
-
-#[derive(Debug)]
-pub enum ColorParseError {
-    InvalidFormat,
-    InvalidHex,
-    InvalidRgb,
-    InvalidHsl,
-    UnknownNamedColor,
-}
-
-impl fmt::Display for ColorParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ColorParseError::InvalidFormat => write!(f, "Invalid color format"),
-            ColorParseError::InvalidHex => write!(f, "Invalid hex color code"),
-            ColorParseError::InvalidRgb => write!(f, "Invalid RGB format. Expected format: R,G,B"),
-            ColorParseError::InvalidHsl => {
-                write!(f, "Invalid HSL format. Expected format: hsl(H,S%,L%)")
-            }
-            ColorParseError::UnknownNamedColor => write!(f, "Unknown named color"),
-        }
-    }
-}
-
-impl Error for ColorParseError {}
-
-impl FromStr for Color {
-    type Err = ColorParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s_lower = s.to_lowercase();
-
-        // Try named color first
-        if let Ok(named) = NamedColor::from_str(s, true) {
-            return Ok(Color::Named(named));
-        }
-
-        // Try hex color (#RRGGBB or #RGB)
-        if s.starts_with('#') {
-            return parse_hex_color(s);
-        }
-
-        // Try HSL (hsl(180,100%,50%))
-        if s_lower.starts_with("hsl(") && s.ends_with(')') {
-            return parse_hsl_color(s);
-        }
-
-        // Try RGB tuple (255,0,128)
-        if s.contains(',') {
-            return parse_rgb_color(s);
-        }
-
-        // Try ANSI code (number between 0-255)
-        if let Ok(code) = s.parse::<u8>() {
-            return Ok(Color::Ansi(code));
-        }
-
-        Err(ColorParseError::InvalidFormat)
-    }
-}
-
-impl FromStr for NamedColor {
-    type Err = ColorParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::from_str(s, false)
-    }
-}
-
-impl NamedColor {
-    fn from_str(s: &str, ignore_case: bool) -> Result<Self, ColorParseError> {
-        let s = if ignore_case {
-            s.to_lowercase()
-        } else {
-            s.to_string()
-        };
-
-        match s.as_str() {
-            "black" => Ok(NamedColor::Black),
-            "red" => Ok(NamedColor::Red),
-            "green" => Ok(NamedColor::Green),
-            "yellow" => Ok(NamedColor::Yellow),
-            "blue" => Ok(NamedColor::Blue),
-            "magenta" => Ok(NamedColor::Magenta),
-            "cyan" => Ok(NamedColor::Cyan),
-            "white" => Ok(NamedColor::White),
-            "brightblack" | "bright_black" => Ok(NamedColor::BrightBlack),
-            "brightred" | "bright_red" => Ok(NamedColor::BrightRed),
-            "brightgreen" | "bright_green" => Ok(NamedColor::BrightGreen),
-            "brightyellow" | "bright_yellow" => Ok(NamedColor::BrightYellow),
-            "brightblue" | "bright_blue" => Ok(NamedColor::BrightBlue),
-            "brightmagenta" | "bright_magenta" => Ok(NamedColor::BrightMagenta),
-            "brightcyan" | "bright_cyan" => Ok(NamedColor::BrightCyan),
-            "brightwhite" | "bright_white" => Ok(NamedColor::BrightWhite),
-            _ => Err(ColorParseError::UnknownNamedColor),
-        }
-    }
-}
-
-fn parse_hex_color(s: &str) -> Result<Color, ColorParseError> {
-    let hex = s.trim_start_matches('#');
-
-    match hex.len() {
-        3 => {
-            // #RGB format
-            let r = u8::from_str_radix(&hex[0..1].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            let g = u8::from_str_radix(&hex[1..2].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            let b = u8::from_str_radix(&hex[2..3].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
-        }
-        6 => {
-            // #RRGGBB format
-            let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
-        }
-        _ => Err(ColorParseError::InvalidHex),
-    }
-}
-
-fn parse_rgb_color(s: &str) -> Result<Color, ColorParseError> {
-    let parts: Vec<&str> = s.split(',').map(|p| p.trim()).collect();
-    if parts.len() != 3 {
-        return Err(ColorParseError::InvalidRgb);
-    }
-
-    let r = parts[0]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-    let g = parts[1]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-    let b = parts[2]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-
-    Ok(Color::Rgb(r, g, b))
-}
-
-fn parse_hsl_color(s: &str) -> Result<Color, ColorParseError> {
-    let content = s.trim_start_matches("hsl(").trim_end_matches(')');
-    let parts: Vec<&str> = content.split(',').map(|p| p.trim()).collect();
-
-    if parts.len() != 3 {
-        return Err(ColorParseError::InvalidHsl);
-    }
-
-    let h = parts[0]
-        .trim_end_matches(|c: char| !c.is_ascii_digit())
-        .parse::<u16>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-    let s = parts[1]
-        .trim_end_matches('%')
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-    let l = parts[2]
-        .trim_end_matches('%')
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-
-    if h > 360 || s > 100 || l > 100 {
-        return Err(ColorParseError::InvalidHsl);
-    }
-
-    Ok(Color::Hsl(h, s, l))
-}
-
-impl Color {
-    /// Convert color to RGB tuple
-    pub fn to_rgb(&self) -> (u8, u8, u8) {
-        match self {
-            Color::Named(named) => named.to_rgb(),
-            Color::Hex(hex) => {
-                let hex = hex.trim_start_matches('#');
-                match hex.len() {
-                    3 => {
-                        // #RGB format
-                        let r = u8::from_str_radix(&hex[0..1].repeat(2), 16).unwrap_or(0);
-                        let g = u8::from_str_radix(&hex[1..2].repeat(2), 16).unwrap_or(0);
-                        let b = u8::from_str_radix(&hex[2..3].repeat(2), 16).unwrap_or(0);
-                        (r, g, b)
-                    }
-                    6 => {
-                        // #RRGGBB format
-                        let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
-                        let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
-                        let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
-                        (r, g, b)
-                    }
-                    _ => (0, 0, 0),
-                }
-            }
-            Color::Rgb(r, g, b) => (*r, *g, *b),
-            Color::Hsl(h, s, l) => hsl_to_rgb(*h, *s, *l),
-            Color::Ansi(code) => ansi_to_rgb(*code),
-            Color::Truecolor(r, g, b) => (*r, *g, *b),
-        }
-    }
-
-    /// Convert color to ANSI escape code for foreground
-    pub fn to_ansi_fg(&self, color_mode: ColorMode) -> String {
-        match color_mode {
-            ColorMode::Truecolor => self.to_truecolor_fg(),
-            ColorMode::Ansi256 => self.to_ansi256_fg(),
-            ColorMode::Ansi16 => self.to_ansi16_fg(),
-            ColorMode::NoColor => "".to_string(),
-        }
-    }
-
-    fn to_truecolor_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        format!("\x1b[38;2;{};{};{}m", r, g, b)
-    }
-
-    fn to_ansi256_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        let code = rgb_to_ansi256(r, g, b);
-        format!("\x1b[38;5;{}m", code)
-    }
-
-    fn to_ansi16_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        let code = rgb_to_ansi16(r, g, b);
-        format!("\x1b[{}m", code)
-    }
-}
-
-impl NamedColor {
-    pub fn to_rgb(self) -> (u8, u8, u8) {
-        match self {
-            NamedColor::Black => (0, 0, 0),
-            NamedColor::Red => (197, 15, 31),
-            NamedColor::Green => (19, 161, 14),
-            NamedColor::Yellow => (193, 156, 0),
-            NamedColor::Blue => (0, 55, 218),
-            NamedColor::Magenta => (136, 23, 152),
-            NamedColor::Cyan => (58, 150, 221),
-            NamedColor::White => (204, 204, 204),
-            NamedColor::BrightBlack => (118, 118, 118),
-            NamedColor::BrightRed => (231, 72, 86),
-            NamedColor::BrightGreen => (22, 198, 12),
-            NamedColor::BrightYellow => (249, 241, 165),
-            NamedColor::BrightBlue => (59, 120, 255),
-            NamedColor::BrightMagenta => (180, 0, 158),
-            NamedColor::BrightCyan => (97, 214, 214),
-            NamedColor::BrightWhite => (242, 242, 242),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ColorMode {
-    Truecolor,
-    Ansi256,
-    Ansi16,
-    NoColor,
-}
-
-/// Convert HSL to RGB
-fn hsl_to_rgb(h: u16, s: u8, l: u8) -> (u8, u8, u8) {
-    let h = h as f32 / 360.0;
-    let s = s as f32 / 100.0;
-    let l = l as f32 / 100.0;
-
-    let (r, g, b) = if s == 0.0 {
-        (l, l, l)
-    } else {
-        let hue_to_rgb = |p: f32, q: f32, t: f32| -> f32 {
-            let mut t = t;
-            if t < 0.0 {
-                t += 1.0;
-            }
-            if t > 1.0 {
-                t -= 1.0;
-            }
-            if t < 1.0 / 6.0 {
-                return p + (q - p) * 6.0 * t;
-            }
-            if t < 1.0 / 2.0 {
-                return q;
-            }
-            if t < 2.0 / 3.0 {
-                return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
-            }
-            p
-        };
-
-        let q = if l < 0.5 {
-            l * (1.0 + s)
-        } else {
-            l + s - l * s
-        };
-        let p = 2.0 * l - q;
-
-        (
-            hue_to_rgb(p, q, h + 1.0 / 3.0),
-            hue_to_rgb(p, q, h),
-            hue_to_rgb(p, q, h - 1.0 / 3.0),
-        )
-    };
-
-    (
-        (r * 255.0).round() as u8,
-        (g * 255.0).round() as u8,
-        (b * 255.0).round() as u8,
-    )
-}
-
-/// Convert RGB to ANSI 256 color code
-fn rgb_to_ansi256(r: u8, g: u8, b: u8) -> u8 {
-    // Calculate grayscale value
-    let gray = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;
-
-    // Check if it's a grayscale color
-    if r == g && g == b {
-        // Grayscale ramp (232-255)
-        if gray <= 8 {
-            16
-        } else if gray >= 248 {
-            231
-        } else {
-            ((gray as f32 - 8.0) / 247.0 * 24.0).round() as u8 + 232
-        }
-    } else {
-        // Color cube (16-231)
-        let r = (r as f32 / 255.0 * 5.0).round() as u8;
-        let g = (g as f32 / 255.0 * 5.0).round() as u8;
-        let b = (b as f32 / 255.0 * 5.0).round() as u8;
-
-        16 + (r * 36) + (g * 6) + b
-    }
-}
-
-/// Convert RGB to ANSI 16 color code
-pub(crate) fn rgb_to_ansi16(r: u8, g: u8, b: u8) -> u8 {
-    // Calculate brightness (perceived luminance)
-    let brightness = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;
-    let is_bright = brightness > 128;
-
-    // Determine base color using simple thresholding on each channel, producing an index 0..7
-    let r_on = r > 128;
-    let g_on = g > 128;
-    let b_on = b > 128;
-    let base_idx = (r_on as u8) + (g_on as u8) * 2 + (b_on as u8) * 4; // 0..7
-
-    // SGR color codes: 30..37 for normal, 90..97 for bright
-    if is_bright {
-        90 + base_idx
-    } else {
-        30 + base_idx
-    }
-}
-
-/// Convert ANSI color code to RGB
-fn ansi_to_rgb(code: u8) -> (u8, u8, u8) {
-    match code {
-        // Standard 16 colors
-        0 => (0, 0, 0),        // Black
-        1 => (128, 0, 0),      // Red
-        2 => (0, 128, 0),      // Green
-        3 => (128, 128, 0),    // Yellow
-        4 => (0, 0, 128),      // Blue
-        5 => (128, 0, 128),    // Magenta
-        6 => (0, 128, 128),    // Cyan
-        7 => (192, 192, 192),  // White
-        8 => (128, 128, 128),  // Bright Black
-        9 => (255, 0, 0),      // Bright Red
-        10 => (0, 255, 0),     // Bright Green
-        11 => (255, 255, 0),   // Bright Yellow
-        12 => (0, 0, 255),     // Bright Blue
-        13 => (255, 0, 255),   // Bright Magenta
-        14 => (0, 255, 255),   // Bright Cyan
-        15 => (255, 255, 255), // Bright White
-
-        // 256-color mode
-        16..=231 => {
-            // Color cube
-            let code = code - 16;
-            let r = ((code / 36) % 6) * 51;
-            let g = ((code / 6) % 6) * 51;
-            let b = (code % 6) * 51;
-            (r, g, b)
-        }
-
-        232..=255 => {
-            // Grayscale ramp
-            let gray = (code - 232) * 10 + 8;
-            (gray, gray, gray)
-        }
-    }
-}
-
-// (Removed older detect_color_mode to keep a single refactored implementation)
-
-/// Try to enable ANSI (virtual terminal processing) on Windows consoles.
-/// Returns true if enabling succeeded or isn't necessary, false otherwise.
-#[cfg(windows)]
-pub fn enable_windows_ansi() -> bool {
-    // no ptr usage required; removed unused import
-    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
-    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
-    use winapi::um::processenv::GetStdHandle;
-    use winapi::um::winbase::STD_OUTPUT_HANDLE;
-    use winapi::um::wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-
-    unsafe {
-        let stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        if stdout == INVALID_HANDLE_VALUE {
-            return false;
-        }
-
-        let mut mode: u32 = 0;
-        if GetConsoleMode(stdout, &mut mode) == 0 {
-            return false;
-        }
-
-        let new_mode = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-        if SetConsoleMode(stdout, new_mode) == 0 {
-            return false;
-        }
-    }
-
-    true
-}
-
-/// Detect the parent shell name on Windows, using environment hints.
-#[cfg(windows)]
-pub fn detect_windows_shell() -> Option<String> {
-    // Heuristic checks using common env vars
-    if std::env::var("PSModulePath").is_ok() {
-        return Some("powershell".to_string());
-    }
-    if std::env::var("PWshPROFILE").is_ok() || std::env::var("PWSH_VERSION").is_ok() {
-        return Some("pwsh".to_string());
-    }
-    if let Ok(comspec) = std::env::var("COMSPEC") {
-        if comspec.to_lowercase().ends_with("cmd.exe") {
-            return Some("cmd.exe".to_string());
-        }
-    }
-    if std::env::var("WT_SESSION").is_ok() {
-        return Some("windows_terminal".to_string());
-    }
-    None
-}
-
-#[cfg(not(windows))]
-#[allow(dead_code)]
-pub fn detect_windows_shell() -> Option<String> {
-    None
-}
-
-/// Detect the parent shell name on Windows, using the sysinfo crate.
-pub fn detect_color_mode() -> ColorMode {
-    if std::env::var("NO_COLOR").is_ok() {
-        return ColorMode::NoColor;
-    }
-
-    // Early checks
-    if std::env::var("COLORTERM")
-        .is_ok_and(|colorterm| colorterm.contains("truecolor") || colorterm.contains("24bit"))
-    {
-        return ColorMode::Truecolor;
-    }
-
-    if std::env::var("TERM").is_ok_and(|term| term.contains("256color")) {
-        return ColorMode::Ansi256;
-    }
-    if std::env::var("TERM").is_ok_and(|term| term.contains("color")) {
-        return ColorMode::Ansi16;
-    }
-
-    // Default fallback
-    #[cfg(windows)]
-    let mut mode = ColorMode::Ansi16;
-    #[cfg(not(windows))]
-    let mode = ColorMode::Ansi16;
-
-    // If running on Windows, try to enable ANSI (virtual terminal processing)
-    #[cfg(windows)]
-    {
-        if enable_windows_ansi() {
-            // Re-check for a better mode
-            if let Ok(colorterm) = std::env::var("COLORTERM") {
-                if colorterm.contains("truecolor") || colorterm.contains("24bit") {
-                    mode = ColorMode::Truecolor;
-                }
-            }
-            if let Ok(term) = std::env::var("TERM") {
-                if term.contains("256color") {
-                    mode = ColorMode::Ansi256;
-                }
-            }
-        } else if let Some(shell) = detect_windows_shell() {
-            let shell = shell.to_lowercase();
-            if shell.contains("cmd.exe") {
-                // cmd historically doesn't support ANSI; use 16 colors fallback
-                mode = ColorMode::Ansi16;
-            } else if shell.contains("powershell") || shell.contains("pwsh") {
-                if let Ok(term) = std::env::var("TERM") {
-                    if term.contains("256color") {
-                        mode = ColorMode::Ansi256;
-                    }
-                }
-            } else {
-                mode = ColorMode::Ansi16;
-            }
-        }
-    }
-
-    mode
-}
-
-/// Convert RGB to HSV
-fn rgb_to_hsv((r, g, b): (u8, u8, u8)) -> (f32, f32, f32) {
-    let r = r as f32 / 255.0;
-    let g = g as f32 / 255.0;
-    let b = b as f32 / 255.0;
-
-    let max = r.max(g).max(b);
-    let min = r.min(g).min(b);
-    let delta = max - min;
-
-    let h = if delta == 0.0 {
-        0.0
-    } else if max == r {
-        60.0 * (((g - b) / delta) % 6.0)
-    } else if max == g {
-        60.0 * (((b - r) / delta) + 2.0)
-    } else {
-        60.0 * (((r - g) / delta) + 4.0)
-    };
-
-    let h = if h < 0.0 { h + 360.0 } else { h };
-
-    let s = if max == 0.0 { 0.0 } else { delta / max };
-    let v = max;
-
-    (h, s, v)
-}
-
-/// Linear interpolation between two colors in HSV space
-pub fn lerp_color_hsv(start: &Color, end: &Color, t: f32) -> Color {
-    let (h1, s1, v1) = rgb_to_hsv(start.to_rgb());
-    let (h2, s2, v2) = rgb_to_hsv(end.to_rgb());
-
-    // Handle hue interpolation correctly (shortest path around the color wheel)
-    let h_diff = (h2 - h1 + 180.0) % 360.0 - 180.0;
-    let h = (h1 + h_diff * t + 360.0) % 360.0;
-
-    let s = s1 + (s2 - s1) * t;
-    let v = v1 + (v2 - v1) * t;
-
-    let (r, g, b) = hsv_to_rgb(h, s, v);
-    Color::Truecolor(r, g, b)
-}
-
-/// Convert HSV to RGB
-fn hsv_to_rgb(h: f32, s: f32, v: f32) -> (u8, u8, u8) {
-    let c = v * s;
-    let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0).abs());
-    let m = v - c;
-
-    let (r, g, b) = match h {
-        h if (0.0..60.0).contains(&h) => (c, x, 0.0),
-        h if (60.0..120.0).contains(&h) => (x, c, 0.0),
-        h if (120.0..180.0).contains(&h) => (0.0, c, x),
-        h if (180.0..240.0).contains(&h) => (0.0, x, c),
-        h if (240.0..300.0).contains(&h) => (x, 0.0, c),
-        _ => (c, 0.0, x),
-    };
-
-    (
-        ((r + m) * 255.0).round() as u8,
-        ((g + m) * 255.0).round() as u8,
-        ((b + m) * 255.0).round() as u8,
-    )
-}
diff --git a/src/colors.c b/src/colors.c
new file mode 100644
index 0000000..b41f775
--- /dev/null
+++ b/src/colors.c
@@ -0,0 +1,3 @@
+#include "../defs/all.h"
+//i'm gonna do this later
+void Void(void){}; 
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..adbd1d3
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,357 @@
+#include "../defs/all.h"
+#include "../defs/mikuart.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define VERSION "0.1.0"
+//proud.release.patch 
+
+char **getmikuart(int style){
+    if(style < 0)
+        style = rand() % migucount;
+    return mikuart[style];
+}
+
+struct win {
+    int winwidth;
+    int winheight;
+};
+
+static struct win term = {80, 24};  //if the function fails this is the defualt
+
+#ifdef _WIN32
+    #include <windows.h>
+    //i have no way to test this because i don't have any windows pc in my house qwq 
+    //(i asked claude to write this for windows because i never looked at the windows api in my life)
+    static void getterminalsize(void) {
+        SetConsoleOutputCP(CP_UTF8);
+        CONSOLE_SCREEN_BUFFER_INFO csbi;
+        if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
+            term.winwidth  = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+            term.winheight = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+        }
+    }
+#else //or this if they're not on windows which should be posixish like linux or macos
+    #include <sys/ioctl.h>
+    #include <unistd.h>
+
+    static void getterminalsize(void) {
+        struct winsize ws;
+        if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0) {
+            if(ws.ws_col > 0)
+                term.winwidth  = ws.ws_col;
+            if(ws.ws_row > 0)
+                term.winheight = ws.ws_row;
+        }
+    }
+#endif
+
+#define TERMINALWIDTH term.winwidth
+#define TERMINALHEIGHT term.winheight
+
+static int count;
+
+static void freelines(char **lines){
+    if(!lines) return;
+    for(int i = 0; lines[i] != NULL; i++)
+        free(lines[i]);
+    free(lines);
+}
+
+char **wraptext(const char *text, int max, int *count){
+    char *copy = strdup(text);
+    char *current_line = calloc(strlen(text)+1, sizeof(char));
+    char **lines = NULL;
+    *count = 0; 
+
+    char *tok = strtok(copy, " \t\n");   
+    while(tok != NULL){ 
+        if(strlen(current_line)+strlen(tok) < (size_t)max){
+            if(current_line[0] != '\0'){
+                strcat(current_line, " ");
+            }
+            strcat(current_line, tok);
+        } else{
+            if(current_line[0] != '\0'){
+                lines = realloc(lines, (*count + 2) * sizeof(char *));
+                lines[*count] = strdup(current_line); 
+                (*count)++;  
+                lines[*count] = NULL;
+            }                                      
+            strcpy(current_line, tok);  
+        }
+        tok = strtok(NULL, " \t\n"); 
+    }
+
+    if(current_line[0] != '\0'){
+        lines = realloc(lines, (*count + 2) * sizeof(char *)); 
+        lines[*count] = strdup(current_line);
+        (*count)++;
+        lines[*count] = NULL;
+    }
+
+    free(copy);
+    free(current_line);
+    return lines;
+}
+
+#define MAX_BUBBLE_WIDTH 50
+#define MIN_BUBBLE_WIDTH 20
+char **getbubblelines(char *text){
+    char **templines = wraptext(text, MAX_BUBBLE_WIDTH - 4, &count);
+    if(templines == NULL)
+        return NULL;
+
+    size_t content_width = 0;
+    for (int i = 0; templines[i] != NULL; i++) {
+        size_t current_len = strlen(templines[i]);
+        if (current_len > content_width)
+            content_width = current_len;
+    }
+    freelines(templines);
+
+    int bubble_width = content_width + 4;
+    if(bubble_width < MIN_BUBBLE_WIDTH) bubble_width = MIN_BUBBLE_WIDTH;
+    if(bubble_width > MAX_BUBBLE_WIDTH) bubble_width = MAX_BUBBLE_WIDTH;
+
+    char **lines = wraptext(text, bubble_width - 4, &count);
+
+    const char *top_left = "╭";
+    const char *top_right = "╮";
+    const char *bottom_left = "╰";
+    const char *bottom_right = "╯";
+    const char *horizontal = "─";
+    const char *vertical = "│";
+    
+    char **bubblelines = calloc(count + 5, sizeof(char *));      
+    bubblelines[0] = malloc(strlen(top_left) + strlen(horizontal) * bubble_width + strlen(top_right) + 1);
+    strcpy(bubblelines[0], top_left);
+    for (int i = 0; i < bubble_width; i++)
+        strcat(bubblelines[0], horizontal);
+    strcat(bubblelines[0], top_right);
+    
+    for (int i = 0; lines[i] != NULL; i++) {
+        int line_width = strlen(lines[i]);
+        int padding_needed = (bubble_width - 2) - line_width;
+        if (padding_needed < 0) padding_needed = 0;
+        int left_padding = padding_needed / 2;
+        int right_padding = padding_needed - left_padding;
+
+        bubblelines[i + 1] = malloc(strlen(vertical) * 2 + 2 + line_width + padding_needed + 1);
+        sprintf(bubblelines[i + 1], "%s %*s%s%*s %s",vertical, left_padding, "", lines[i], right_padding, "", vertical);
+    }
+
+    bubblelines[count+1] = malloc(strlen(bottom_left) + strlen(horizontal) * bubble_width + strlen(bottom_right) + 1);
+    strcpy(bubblelines[count+1], bottom_left);
+    for (int i = 0; i < bubble_width; i++)
+        strcat(bubblelines[count+1], horizontal);
+    strcat(bubblelines[count+1], bottom_right);
+
+    bubblelines[count + 2] = strdup("\\");   
+    bubblelines[count + 3] = strdup(" \\"); 
+
+    freelines(lines);
+    return bubblelines;
+}
+
+static void print_help(void){
+    printf("A \"cowsay\" clone with Hatsune Miku ASCII art and speech bubbles.\n\n"
+           "Usage: mikusays [OPTIONS] [TEXT]\n\n"
+           "Arguments:\n"
+           "  [TEXT]  Text to display in the speech bubble\n\n"
+           "Options:\n"
+           "  -s, --style <STYLE>  Style of the Miku art. A random one is chosen if not specified\n"
+           "  -l, --list           List all available art styles with their indices\n"
+           "  -h, --help           Print help\n"
+           "  -V, --version        Print version\n");
+}
+
+static void list_all_art_styles(void){
+    printf("Available Miku art styles:\n");
+    printf("==========================\n");
+    printf("Total styles: %zu\n", migucount);
+
+    for(size_t i = 0; i < migucount; i++){
+        printf("\n--- Style %zu ---\n", i);
+        for(int j = 0; mikuart[i][j] != NULL; j++)
+            printf("%s\n", mikuart[i][j]);
+    }
+
+    printf("\nUse --style <number> to select a specific style, or omit for random selection.\n");
+}
+
+
+//display width in columns: counts utf 8 codepoints (skips continuation bytes)
+//assumes every character is 1 column wide
+//emojis and other bullshit won't work bu tthat's okay since who the fuck will try to put '🥺' into this
+static int displaywidth(const char *s){
+    int w = 0;
+    for(; *s; s++)
+        if(((unsigned char)*s & 0xC0) != 0x80)
+            w++;
+    return w;
+}
+
+void draw_miku_says(char *text, int style){
+    char **speech_bubble_lines = getbubblelines(text);
+    if(speech_bubble_lines == NULL)
+        return;
+    char **miku_art = getmikuart(style);
+
+    int available_width = TERMINALWIDTH;
+    int available_height = TERMINALHEIGHT; 
+
+    
+    
+
+    int max_content_width = 0;
+    for(int i = 0; speech_bubble_lines[i] != NULL; i++){
+        int width = displaywidth(speech_bubble_lines[i]);
+        if(width> max_content_width) max_content_width = width;
+    }
+    for(int i = 0; miku_art[i] != NULL; i++){
+        int width = displaywidth(miku_art[i]);
+        if(width > max_content_width) max_content_width = width;
+    }
+
+    int overall_left_padding;
+    if(available_width > max_content_width){
+        overall_left_padding = (available_width - max_content_width) / 2;
+    }else{
+    overall_left_padding = 0;
+    }
+    
+    int bubble_width = displaywidth(speech_bubble_lines[0]); 
+    
+    const char *first_miku_line = miku_art[0] ? miku_art[0] : "";
+    int tail_pos = 0;
+    const char *ptr = first_miku_line;
+    while (*ptr == ' ') {
+        ptr += 1;
+        tail_pos++;
+    }
+
+
+    int bubble_center = bubble_width / 2;
+    int miku_tail_absolute_pos = overall_left_padding + tail_pos;
+    
+    int bubble_left_padding; 
+    if(miku_tail_absolute_pos >= bubble_center){
+        bubble_left_padding = miku_tail_absolute_pos - bubble_center;
+    }else{
+        bubble_left_padding = 0;
+    }
+
+    int bubble_line_count = 0;
+    for(int i = 0; speech_bubble_lines[i] != NULL; i++){
+        bubble_line_count++;
+    }
+
+    int art_count = 0;
+    while(miku_art[art_count] != NULL) art_count++;
+
+    char **all_content_lines = calloc(bubble_line_count + art_count + 1, sizeof(char *));
+    for(int i = 0; i < bubble_line_count; i++)
+        all_content_lines[i] = speech_bubble_lines[i];
+    for(int i = 0; i < art_count; i++)
+        all_content_lines[bubble_line_count + i] = miku_art[i];
+
+
+    int content_height = bubble_line_count + art_count; 
+
+    
+    int top_padding; 
+    if(content_height < available_height){
+        top_padding = (available_height - content_height) / 2;
+    }else{
+        top_padding  = 0;
+    }
+
+    for(int i = 0; i < top_padding; i++){
+        printf("\n"); 
+    }
+
+    for(int i = 0; all_content_lines[i] != NULL; i++){
+        int is_bubble_line = i < bubble_line_count;
+        int is_tail_line = is_bubble_line && (i == bubble_line_count - 2 || i == bubble_line_count - 1);
+
+        int padding;
+        if(is_tail_line)
+            padding = overall_left_padding + tail_pos;
+        else if(is_bubble_line)
+            padding = bubble_left_padding;
+        else
+            padding = overall_left_padding;
+
+        printf("%*s%s\n", padding, "", all_content_lines[i]);
+    }
+
+    for(int i = 0; i < top_padding; i++){
+        printf("\n"); 
+    }    
+    freelines(speech_bubble_lines);
+    free(all_content_lines);
+}
+
+int main(int argc, char **argv){
+    Void(); //look at all.h 
+    srand(time(NULL));
+    getterminalsize();
+
+    long style = -1;   //-1 means random
+    int list = 0;
+    int ret = 0;
+
+    size_t length = 0;
+    for(int i = 1; i < argc; i++)
+        length += strlen(argv[i]);
+    char *text = malloc(length + argc);
+    if(!text) return 1;
+    *text = '\0';
+
+    for(int i = 1; i < argc; i++){
+        if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0){
+            print_help();
+            goto out;
+        } else if(strcmp(argv[i], "-V") == 0 || strcmp(argv[i], "--version") == 0){
+            printf("mikusays " VERSION "\n");
+            goto out;
+        } else if(strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--list") == 0){
+            list = 1;
+        } else if(strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--style") == 0){
+            if(i + 1 >= argc){ 
+                fprintf(stderr, "error: a value is required for '--style <STYLE>' but none was supplied\n"); 
+                ret = 2;
+                goto out;
+            }
+            i++;
+            char *end;
+            long v = strtol(argv[i], &end, 10);
+            if(*argv[i] == '\0' || *end != '\0'){
+                fprintf(stderr, "error: invalid value '%s' for '--style <STYLE>': not a number\n", argv[i]);
+                ret = 2;
+                goto out;
+            }
+            style = v < 0 ? -1 : v;   //negative = random
+        } else {
+            strcat(text, argv[i]);
+            strcat(text, " ");
+        }
+    }
+
+    if(list){
+        list_all_art_styles();
+    } else if(text[0] == '\0'){
+        fprintf(stderr, "Error: Text is required when not using --list\n");
+        ret = 1;
+    } else if(style >= (long)migucount){
+        fprintf(stderr, "Style %ld does not exist! Choose one between 0 and %zu\n", style, migucount - 1);
+        ret = 1;
+    } else {
+        draw_miku_says(text, (int)style);
+    }
+//i didn't know you could do labels like in assembly (nasm) this is very useful knowledge 
+out:
+    free(text);
+    return ret;
+}
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 3e6c430..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,905 +0,0 @@
-use clap::error::ErrorKind;
-use clap::{CommandFactory, Parser};
-use crossterm::QueueableCommand;
-use crossterm::style::{Print, ResetColor};
-use crossterm::terminal::size;
-use std::error::Error;
-use std::fmt;
-use std::io::{Write, stdout};
-use std::str::FromStr;
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
-
-mod color;
-mod mikuart;
-use color::{Color, ColorMode, detect_color_mode, lerp_color_hsv};
-use mikuart::get_miku_art;
-
-#[derive(Parser)]
-#[command(version, about, long_about = None)]
-pub struct Args {
-    /// Text to display in the speech bubble
-    pub text: Option<String>,
-
-    /// Style of the Miku art. A random one is chosen if not specified
-    #[arg(short, long, value_parser = clap::value_parser!(i32).range(0..))]
-    pub style: Option<i32>,
-
-    /// List all available art styles with their indices
-    #[arg(short, long)]
-    pub list: bool,
-
-    /// Apply a smooth rainbow gradient across the ASCII art
-    #[arg(long, conflicts_with_all = ["color", "gradient"])]
-    pub rainbow: bool,
-
-    /// Saturation level for rainbow gradient (0-100)
-    #[arg(long, default_value_t = 100, value_parser = clap::value_parser!(u8).range(0..=100))]
-    pub saturation: u8,
-
-    /// Brightness level for rainbow gradient (0-100)
-    #[arg(long, default_value_t = 50, value_parser = clap::value_parser!(u8).range(0..=100))]
-    pub brightness: u8,
-
-    /// Override with a single solid color
-    #[arg(long, value_name = "COLOR", conflicts_with = "gradient")]
-    pub color: Option<String>,
-
-    /// Define a custom two-color gradient (e.g., --gradient red:blue)
-    #[arg(long, value_name = "START:END")]
-    pub gradient: Option<String>,
-
-    /// Disable all coloring (respects NO_COLOR environment variable)
-    #[arg(long)]
-    pub no_color: bool,
-    /// Print color detection/debug info and exit
-    #[arg(long)]
-    pub color_debug: bool,
-}
-
-#[derive(Debug)]
-pub struct ColorConfig {
-    pub mode: ColorMode,
-    pub rainbow: bool,
-    pub saturation: u8,
-    pub brightness: u8,
-    pub single_color: Option<Color>,
-    pub gradient: Option<(Color, Color)>,
-    pub color_cache: Vec<Color>,
-    pub ansi_enabled: bool,
-    pub debug: bool,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct ColorConfigError(String);
-
-impl fmt::Display for ColorConfigError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.0)
-    }
-}
-
-impl Error for ColorConfigError {}
-
-const COLOR_FORMAT_HELP: &str =
-    "expected a named color, #RRGGBB, #RGB, R,G,B, hsl(H,S%,L%), or ANSI value 0-255";
-
-pub fn parse_color_args(args: &Args) -> Result<ColorConfig, ColorConfigError> {
-    // Detect color mode
-    let mut color_mode = detect_color_mode();
-
-    // Override with --no-color if specified
-    if args.no_color {
-        color_mode = ColorMode::NoColor;
-    }
-
-    // Parse single color if provided
-    let single_color = args
-        .color
-        .as_deref()
-        .map(|color_str| {
-            Color::from_str(color_str).map_err(|error| {
-                ColorConfigError(format!(
-                    "invalid color '{color_str}': {error}; {COLOR_FORMAT_HELP}"
-                ))
-            })
-        })
-        .transpose()?;
-
-    // Parse gradient if provided
-    let gradient = if let Some(gradient_str) = args.gradient.as_deref() {
-        let (start_str, end_str) = gradient_str.split_once(':').ok_or_else(|| {
-            ColorConfigError(
-                "invalid gradient: expected START:END (for example, red:blue)".to_string(),
-            )
-        })?;
-
-        if start_str.is_empty() || end_str.is_empty() || end_str.contains(':') {
-            return Err(ColorConfigError(
-                "invalid gradient: expected exactly two colors as START:END".to_string(),
-            ));
-        }
-
-        let start = Color::from_str(start_str).map_err(|error| {
-            ColorConfigError(format!(
-                "invalid gradient start '{start_str}': {error}; {COLOR_FORMAT_HELP}"
-            ))
-        })?;
-        let end = Color::from_str(end_str).map_err(|error| {
-            ColorConfigError(format!(
-                "invalid gradient end '{end_str}': {error}; {COLOR_FORMAT_HELP}"
-            ))
-        })?;
-
-        Some((start, end))
-    } else {
-        None
-    };
-
-    // Keep this validation for direct callers as well as Clap-parsed CLI input.
-    if args.rainbow && single_color.is_some() {
-        return Err(ColorConfigError(
-            "--rainbow cannot be used with --color".to_string(),
-        ));
-    }
-
-    if args.rainbow && gradient.is_some() {
-        return Err(ColorConfigError(
-            "--rainbow cannot be used with --gradient".to_string(),
-        ));
-    }
-
-    if single_color.is_some() && gradient.is_some() {
-        return Err(ColorConfigError(
-            "--color cannot be used with --gradient".to_string(),
-        ));
-    }
-
-    // Determine if ANSI is enabled (Windows toggle helper) — don't enable if --no-color
-    #[cfg(windows)]
-    let ansi_enabled = !args.no_color && color::enable_windows_ansi();
-    #[cfg(not(windows))]
-    let ansi_enabled = false;
-
-    Ok(ColorConfig {
-        mode: color_mode,
-        rainbow: args.rainbow,
-        saturation: args.saturation,
-        brightness: args.brightness,
-        single_color,
-        gradient,
-        color_cache: Vec::new(),
-        ansi_enabled,
-        debug: args.color_debug,
-    })
-}
-
-pub fn get_speech_bubble_lines(text: &str) -> Vec<String> {
-    const MAX_BUBBLE_WIDTH: usize = 50;
-    const MIN_BUBBLE_WIDTH: usize = 20;
-
-    let temp_lines = wrap_text(text, MAX_BUBBLE_WIDTH - 4);
-
-    let content_width = temp_lines
-        .iter()
-        .map(|line| line.width())
-        .max()
-        .unwrap_or(0);
-
-    let bubble_width = (content_width + 4).clamp(MIN_BUBBLE_WIDTH, MAX_BUBBLE_WIDTH);
-
-    let lines = wrap_text(text, bubble_width - 4);
-    let mut bubble_lines = Vec::new();
-
-    let top_left = '╭';
-    let top_right = '╮';
-    let bottom_left = '╰';
-    let bottom_right = '╯';
-    let horizontal = '─';
-    let vertical = '│';
-
-    bubble_lines.push(format!(
-        "{}{}{}",
-        top_left,
-        horizontal.to_string().repeat(bubble_width),
-        top_right
-    ));
-
-    for line in &lines {
-        let line_display_width = line.width();
-        let padding_needed = (bubble_width - 2).saturating_sub(line_display_width);
-        let left_padding = padding_needed / 2;
-        let right_padding = padding_needed - left_padding;
-
-        bubble_lines.push(format!(
-            "{} {}{}{} {}",
-            vertical,
-            " ".repeat(left_padding),
-            line,
-            " ".repeat(right_padding),
-            vertical
-        ));
-    }
-
-    bubble_lines.push(format!(
-        "{}{}{}",
-        bottom_left,
-        horizontal.to_string().repeat(bubble_width),
-        bottom_right
-    ));
-
-    bubble_lines.push("\\".to_string());
-    bubble_lines.push(" \\".to_string());
-
-    bubble_lines
-}
-
-pub fn wrap_text(text: &str, max_width: usize) -> Vec<String> {
-    if max_width == 0 {
-        return if text.is_empty() {
-            Vec::new()
-        } else {
-            vec![text.to_string()]
-        };
-    }
-
-    let mut lines = Vec::new();
-    let mut current_line = String::new();
-
-    for word in text.split_whitespace() {
-        let word_width = word.width();
-        let current_width = current_line.width();
-        let separator_width = usize::from(!current_line.is_empty());
-
-        if word_width <= max_width && current_width + separator_width + word_width <= max_width {
-            if !current_line.is_empty() {
-                current_line.push(' ');
-            }
-            current_line.push_str(word);
-            continue;
-        }
-
-        if !current_line.is_empty() {
-            lines.push(std::mem::take(&mut current_line));
-        }
-
-        if word_width <= max_width {
-            current_line.push_str(word);
-            continue;
-        }
-
-        let chunks = split_word_by_width(word, max_width);
-        let last_index = chunks.len().saturating_sub(1);
-        for (index, chunk) in chunks.into_iter().enumerate() {
-            if index == last_index && chunk.width() < max_width {
-                current_line = chunk;
-            } else {
-                lines.push(chunk);
-            }
-        }
-    }
-
-    if !current_line.is_empty() {
-        lines.push(current_line);
-    }
-
-    lines
-}
-
-fn split_word_by_width(word: &str, max_width: usize) -> Vec<String> {
-    let mut chunks = Vec::new();
-    let mut chunk = String::new();
-    let mut chunk_width = 0;
-
-    for character in word.chars() {
-        let character_width = character.width().unwrap_or(0);
-        if !chunk.is_empty() && chunk_width + character_width > max_width {
-            chunks.push(std::mem::take(&mut chunk));
-            chunk_width = 0;
-        }
-        chunk.push(character);
-        chunk_width += character_width;
-    }
-
-    if !chunk.is_empty() {
-        chunks.push(chunk);
-    }
-
-    chunks
-}
-
-pub fn generate_rainbow_cache(color_config: &mut ColorConfig, total_chars: usize) {
-    color_config.color_cache.clear();
-
-    if total_chars == 0 {
-        return;
-    }
-
-    // Generate smooth rainbow gradient across all characters
-    for i in 0..total_chars {
-        let t = i as f32 / total_chars as f32;
-        let hue = t * 360.0; // Full hue spectrum from 0 to 360
-
-        // Create color with specified saturation and brightness
-        let color = Color::Hsl(
-            hue.round() as u16,
-            color_config.saturation,
-            color_config.brightness,
-        );
-        color_config.color_cache.push(color);
-    }
-}
-
-pub fn generate_gradient_cache(
-    color_config: &mut ColorConfig,
-    start: &Color,
-    end: &Color,
-    total_chars: usize,
-) {
-    color_config.color_cache.clear();
-
-    if total_chars == 0 {
-        return;
-    }
-
-    // Generate smooth gradient across all characters
-    for i in 0..total_chars {
-        let t = if total_chars == 1 {
-            0.0
-        } else {
-            i as f32 / (total_chars - 1) as f32
-        };
-        let color = lerp_color_hsv(start, end, t);
-        color_config.color_cache.push(color);
-    }
-}
-
-fn list_all_art_styles() {
-    println!("Available Miku art styles:");
-    println!("==========================");
-
-    // Get all art styles to determine the count
-    let all_art = get_miku_art(None, Some(true));
-    let styles_count = all_art.len();
-    println!("Total styles: {}", styles_count);
-
-    for i in 0..styles_count {
-        println!("\n--- Style {} ---", i);
-        let art = get_miku_art(Some(i as i32), Some(false));
-        for line in art {
-            println!("{}", line);
-        }
-    }
-
-    println!("\nUse --style <number> to select a specific style, or omit for random selection.");
-    println!("\nColor Options:");
-    println!("  --rainbow                Apply a smooth rainbow gradient");
-    println!("  --saturation <0-100>     Set rainbow saturation level (default: 100)");
-    println!("  --brightness <0-100>     Set rainbow brightness level (default: 50)");
-    println!(
-        "  --color <COLOR>          Set a single solid color (supports named colors, hex, rgb, hsl, ansi)"
-    );
-    println!("  --gradient <START:END>   Define a custom two-color gradient");
-    println!("  --no-color               Disable all coloring");
-    println!("\nColor Format Examples:");
-    println!("  --color red              Named color");
-    println!("  --color #FF0000          Hex color");
-    println!("  --color 255,0,128        RGB tuple");
-    println!("  --color hsl(180,100%,50%) HSL value");
-    println!("  --color 93               ANSI color code");
-    println!("  --gradient red:blue      Custom gradient");
-}
-
-fn draw_miku_says(
-    text: &str,
-    style: i32,
-    color_config: &mut ColorConfig,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let speech_bubble_lines = get_speech_bubble_lines(text);
-    let miku_art = get_miku_art(Some(style), None);
-
-    // Distribute colors across characters that are actually colored.
-    let total_chars: usize = miku_art
-        .iter()
-        .map(|line| {
-            line.chars()
-                .filter(|character| !character.is_whitespace())
-                .count()
-        })
-        .sum();
-
-    // Generate color cache if needed
-    if color_config.rainbow {
-        generate_rainbow_cache(color_config, total_chars);
-    } else if let Some((start, end)) = color_config.gradient.clone() {
-        generate_gradient_cache(color_config, &start, &end, total_chars);
-    }
-
-    let (window_width, window_height) = size()?;
-    let available_width = window_width as usize;
-
-    let mut all_content_lines = Vec::new();
-    all_content_lines.extend(speech_bubble_lines.clone());
-    all_content_lines.extend(miku_art.iter().map(|s| s.to_string()));
-
-    let max_content_width = all_content_lines
-        .iter()
-        .map(|l| l.width())
-        .max()
-        .unwrap_or(0);
-
-    let overall_left_padding = if available_width > max_content_width {
-        (available_width - max_content_width) / 2
-    } else {
-        0
-    };
-
-    let bubble_width = speech_bubble_lines
-        .first()
-        .map(|line| line.width())
-        .unwrap_or(0);
-
-    let first_miku_line = miku_art.first().unwrap_or(&"");
-    let tail_pos = first_miku_line
-        .chars()
-        .position(|c| !c.is_whitespace())
-        .unwrap_or(0);
-
-    let bubble_center = bubble_width / 2;
-    let miku_tail_absolute_pos = overall_left_padding + tail_pos;
-
-    let bubble_left_padding = miku_tail_absolute_pos.saturating_sub(bubble_center);
-
-    let bubble_line_count = speech_bubble_lines.len();
-
-    let content_height = all_content_lines.len();
-    let available_height = window_height as usize;
-
-    let top_padding = if content_height < available_height {
-        (available_height - content_height) / 2
-    } else {
-        0
-    };
-
-    for _ in 0..top_padding {
-        println!();
-    }
-
-    // Track color index for non-whitespace characters
-    let mut color_index = 0;
-
-    for (i, line) in all_content_lines.iter().enumerate() {
-        let is_bubble_line = i < bubble_line_count;
-        let is_tail_line =
-            is_bubble_line && (i == bubble_line_count - 2 || i == bubble_line_count - 1);
-
-        if is_bubble_line {
-            if is_tail_line {
-                let tail_padding = overall_left_padding + tail_pos;
-                let horizontal_padding = " ".repeat(tail_padding);
-                println!("{horizontal_padding}{line}");
-            } else {
-                let horizontal_padding = " ".repeat(bubble_left_padding);
-                println!("{horizontal_padding}{line}");
-            }
-        } else {
-            let horizontal_padding = " ".repeat(overall_left_padding);
-
-            // Apply coloring to Miku art lines
-            if color_config.mode != ColorMode::NoColor && !color_config.color_cache.is_empty() {
-                // Use crossterm queueing to color characters so it's platform-agnostic
-                let mut stdout = stdout();
-                stdout.queue(Print(horizontal_padding.clone()))?;
-
-                for c in line.chars() {
-                    if c.is_whitespace() {
-                        stdout.queue(Print(c))?;
-                    } else if color_index < color_config.color_cache.len() {
-                        let color = &color_config.color_cache[color_index];
-                        stdout.queue(Print(color.to_ansi_fg(color_config.mode)))?;
-                        stdout.queue(Print(c))?;
-                        stdout.queue(ResetColor)?;
-                        color_index += 1;
-                    } else {
-                        stdout.queue(Print(c))?;
-                    }
-                }
-
-                stdout.queue(Print("\n"))?;
-                stdout.flush()?;
-                continue;
-            } else if color_config.mode != ColorMode::NoColor
-                && let Some(single_color) = &color_config.single_color
-            {
-                // Apply single solid color using crossterm
-                let mut stdout = stdout();
-                stdout.queue(Print(horizontal_padding.clone()))?;
-                stdout.queue(Print(single_color.to_ansi_fg(color_config.mode)))?;
-                stdout.queue(Print(line))?;
-                stdout.queue(ResetColor)?;
-                stdout.queue(Print("\n"))?;
-                stdout.flush()?;
-            } else {
-                // No coloring
-                println!("{}{}", horizontal_padding, line);
-            }
-        }
-    }
-
-    for _ in 0..top_padding {
-        println!();
-    }
-
-    Ok(())
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args = Args::parse();
-
-    if args.list {
-        list_all_art_styles();
-        return Ok(());
-    }
-
-    let text = args.text.clone().unwrap_or_else(|| {
-        eprintln!("Error: Text is required when not using --list");
-        std::process::exit(1);
-    });
-
-    let styles_count = get_miku_art(None, Some(true)).len();
-    let style = match args.style {
-        Some(style) if style as usize >= styles_count => Args::command()
-            .error(
-                ErrorKind::InvalidValue,
-                format!(
-                    "style {style} does not exist; choose a value between 0 and {}",
-                    styles_count - 1
-                ),
-            )
-            .exit(),
-        Some(style) => style,
-        None => -1,
-    };
-
-    // Parse color-related arguments
-    let mut color_config = parse_color_args(&args).unwrap_or_else(|error| {
-        Args::command()
-            .error(ErrorKind::ValueValidation, error.to_string())
-            .exit()
-    });
-
-    if color_config.debug {
-        println!("Detected color mode: {:?}", color_config.mode);
-        println!("ANSI enabled: {}", color_config.ansi_enabled);
-        println!("NO_COLOR: {:?}", std::env::var("NO_COLOR").ok());
-        println!("COLORTERM: {:?}", std::env::var("COLORTERM").ok());
-        println!("TERM: {:?}", std::env::var("TERM").ok());
-        #[cfg(windows)]
-        {
-            println!("Windows shell hint: {:?}", color::detect_windows_shell());
-        }
-        return Ok(());
-    }
-
-    draw_miku_says(&text, style, &mut color_config)?;
-
-    Ok(())
-}
-
-/// MARK: Tests
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::color::{Color, ColorMode};
-
-    #[test]
-    fn test_wrap_text_basic() {
-        let text = "Hello world this is a test";
-        let wrapped = wrap_text(text, 15);
-        assert_eq!(wrapped, vec!["Hello world", "this is a test"]);
-    }
-
-    #[test]
-    fn test_wrap_text_empty() {
-        let text = "";
-        let wrapped = wrap_text(text, 10);
-        assert_eq!(wrapped, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_wrap_text_long_word() {
-        let text = "ThisIsAVeryLongWordThatExceedsMaxWidth";
-        let wrapped = wrap_text(text, 10);
-        assert_eq!(wrapped.concat(), text);
-        assert!(wrapped.iter().all(|line| line.width() <= 10));
-    }
-
-    #[test]
-    fn test_wrap_text_exact_width() {
-        let text = "Hello world";
-        let wrapped = wrap_text(text, 11);
-        assert_eq!(wrapped, vec!["Hello world"]);
-    }
-
-    #[test]
-    fn test_get_speech_bubble_lines_basic() {
-        let text = "Hello";
-        let bubble = get_speech_bubble_lines(text);
-
-        // Should have: top border, text line, bottom border, 2 tail lines
-        assert_eq!(bubble.len(), 5);
-
-        // Check top border
-        assert!(bubble[0].starts_with('╭'));
-        assert!(bubble[0].ends_with('╮'));
-
-        // Check text line
-        assert!(bubble[1].contains("Hello"));
-
-        // Check bottom border
-        assert!(bubble[2].starts_with('╰'));
-        assert!(bubble[2].ends_with('╯'));
-
-        // Check tail
-        assert_eq!(bubble[3], "\\");
-        assert_eq!(bubble[4], " \\");
-    }
-
-    #[test]
-    fn test_get_speech_bubble_lines_long_text() {
-        let text = "This is a very long text that should be wrapped into multiple lines";
-        let bubble = get_speech_bubble_lines(text);
-
-        // Should have: top border, multiple text lines, bottom border, 2 tail lines
-        assert!(bubble.len() > 5);
-
-        // Check top border
-        assert!(bubble[0].starts_with('╭'));
-        assert!(bubble[0].ends_with('╮'));
-
-        // Check bottom border
-        let bottom_idx = bubble.len() - 3;
-        assert!(bubble[bottom_idx].starts_with('╰'));
-        assert!(bubble[bottom_idx].ends_with('╯'));
-    }
-
-    #[test]
-    fn test_parse_color_args_no_color() {
-        let args = Args {
-            text: Some("test".to_string()),
-            style: None,
-            list: false,
-            rainbow: false,
-            saturation: 100,
-            brightness: 50,
-            color: None,
-            gradient: None,
-            no_color: false,
-            color_debug: false,
-        };
-
-        let config = parse_color_args(&args).unwrap();
-        // Don't assert exact color mode since it depends on environment
-        assert!(!config.rainbow);
-        assert_eq!(config.saturation, 100);
-        assert_eq!(config.brightness, 50);
-        assert!(config.single_color.is_none());
-        assert!(config.gradient.is_none());
-        assert!(config.color_cache.is_empty());
-    }
-
-    #[test]
-    fn test_parse_color_args_no_color_explicit() {
-        let args = Args {
-            text: Some("test".to_string()),
-            style: None,
-            list: false,
-            rainbow: false,
-            saturation: 100,
-            brightness: 50,
-            color: None,
-            gradient: None,
-            no_color: true,
-            color_debug: false,
-        };
-
-        let config = parse_color_args(&args).unwrap();
-        assert_eq!(config.mode, ColorMode::NoColor);
-    }
-
-    #[test]
-    fn test_wrap_text_edge_cases() {
-        // Test with single very long word
-        let text = "Supercalifragilisticexpialidocious";
-        let wrapped = wrap_text(text, 10);
-        assert_eq!(wrapped.concat(), text);
-        assert!(wrapped.iter().all(|line| line.width() <= 10));
-
-        // Test with exact width match
-        let text = "Hello world";
-        let wrapped = wrap_text(text, 11);
-        assert_eq!(wrapped, vec!["Hello world"]);
-
-        // Test with multiple spaces
-        let text = "Hello    world";
-        let wrapped = wrap_text(text, 10);
-        assert_eq!(wrapped, vec!["Hello", "world"]);
-    }
-
-    #[test]
-    fn test_get_speech_bubble_lines_edge_cases() {
-        // Test with empty string
-        let bubble = get_speech_bubble_lines("");
-        assert_eq!(bubble.len(), 4); // Should have: top, empty line, bottom, tail (no extra tail line)
-
-        // Test with very long word
-        let text = "Supercalifragilisticexpialidocious";
-        let bubble = get_speech_bubble_lines(text);
-        assert!(bubble.len() >= 5);
-        let border_width = bubble[0].width();
-        assert!(
-            bubble[..bubble.len() - 2]
-                .iter()
-                .all(|line| line.width() == border_width)
-        );
-    }
-
-    #[test]
-    fn test_wrap_text_splits_long_unicode_word_by_display_width() {
-        let wrapped = wrap_text("初音ミク初音ミク初音ミク", 8);
-
-        assert!(wrapped.len() > 1);
-        assert!(wrapped.iter().all(|line| line.width() <= 8));
-    }
-
-    #[test]
-    fn test_generate_rainbow_cache_edge_cases() {
-        let mut config = ColorConfig {
-            mode: ColorMode::Truecolor,
-            rainbow: true,
-            saturation: 100,
-            brightness: 50,
-            single_color: None,
-            gradient: None,
-            color_cache: vec![Color::Hex("#000000".to_string())], // Pre-filled
-            ansi_enabled: false,
-            debug: false,
-        };
-
-        // Test with 0 characters
-        generate_rainbow_cache(&mut config, 0);
-        assert_eq!(config.color_cache.len(), 0);
-
-        // Test with 1 character
-        generate_rainbow_cache(&mut config, 1);
-        assert_eq!(config.color_cache.len(), 1);
-    }
-
-    #[test]
-    fn test_generate_gradient_cache_edge_cases() {
-        let mut config = ColorConfig {
-            mode: ColorMode::Truecolor,
-            rainbow: false,
-            saturation: 100,
-            brightness: 50,
-            single_color: None,
-            gradient: None,
-            color_cache: vec![Color::Hex("#000000".to_string())], // Pre-filled
-            ansi_enabled: false,
-            debug: false,
-        };
-
-        let start = Color::Hex("#FF0000".to_string());
-        let end = Color::Hex("#0000FF".to_string());
-
-        // Test with 0 characters
-        generate_gradient_cache(&mut config, &start, &end, 0);
-        assert_eq!(config.color_cache.len(), 0);
-
-        // Test with 1 character
-        generate_gradient_cache(&mut config, &start, &end, 1);
-        assert_eq!(config.color_cache.len(), 1);
-    }
-
-    #[test]
-    fn test_generate_rainbow_cache() {
-        let mut config = ColorConfig {
-            mode: ColorMode::Truecolor,
-            rainbow: true,
-            saturation: 100,
-            brightness: 50,
-            single_color: None,
-            gradient: None,
-            color_cache: Vec::new(),
-            ansi_enabled: false,
-            debug: false,
-        };
-
-        generate_rainbow_cache(&mut config, 10);
-        assert_eq!(config.color_cache.len(), 10);
-
-        // Check that colors are different (rainbow gradient)
-        let first_color = &config.color_cache[0];
-        let last_color = &config.color_cache[9];
-        assert_ne!(first_color, last_color);
-    }
-
-    #[test]
-    fn test_rgb_to_ansi16_mapping() {
-        // Validate mapping for basic colors
-        assert_eq!(crate::color::rgb_to_ansi16(255, 0, 0), 31);
-        assert_eq!(crate::color::rgb_to_ansi16(255, 255, 255), 97);
-        assert_eq!(crate::color::rgb_to_ansi16(0, 0, 0), 30);
-    }
-
-    #[test]
-    fn test_generate_gradient_cache() {
-        let mut config = ColorConfig {
-            mode: ColorMode::Truecolor,
-            rainbow: false,
-            saturation: 100,
-            brightness: 50,
-            single_color: None,
-            gradient: None,
-            color_cache: Vec::new(),
-            ansi_enabled: false,
-            debug: false,
-        };
-
-        let start = Color::Hex("#FF0000".to_string()); // Red
-        let end = Color::Hex("#0000FF".to_string()); // Blue
-
-        generate_gradient_cache(&mut config, &start, &end, 10);
-        assert_eq!(config.color_cache.len(), 10);
-
-        let first_color = &config.color_cache[0];
-        let last_color = &config.color_cache[9];
-        assert_eq!(first_color.to_rgb(), start.to_rgb());
-        assert_eq!(last_color.to_rgb(), end.to_rgb());
-    }
-
-    #[test]
-    fn test_parse_color_args_reports_conflicts_without_exiting() {
-        let args = Args {
-            text: Some("test".to_string()),
-            style: None,
-            list: false,
-            rainbow: true,
-            saturation: 100,
-            brightness: 50,
-            color: Some("red".to_string()),
-            gradient: None,
-            no_color: false,
-            color_debug: false,
-        };
-
-        let error = parse_color_args(&args).unwrap_err();
-        assert_eq!(error.to_string(), "--rainbow cannot be used with --color");
-    }
-
-    #[test]
-    fn test_color_conversion_respects_terminal_mode() {
-        let red = Color::Rgb(255, 0, 0);
-        assert_eq!(red.to_ansi_fg(ColorMode::Truecolor), "\x1b[38;2;255;0;0m");
-        assert_eq!(red.to_ansi_fg(ColorMode::Ansi256), "\x1b[38;5;196m");
-        assert_eq!(red.to_ansi_fg(ColorMode::Ansi16), "\x1b[31m");
-        assert_eq!(red.to_ansi_fg(ColorMode::NoColor), "");
-    }
-
-    #[test]
-    fn test_parse_color_debug_flag() {
-        let args = Args {
-            text: Some("test".to_string()),
-            style: None,
-            list: false,
-            rainbow: false,
-            saturation: 100,
-            brightness: 50,
-            color: None,
-            gradient: None,
-            no_color: false,
-            color_debug: true,
-        };
-        let config = parse_color_args(&args).unwrap();
-        assert!(config.debug);
-    }
-}
diff --git a/src/mikuart.rs b/src/mikuart.rs
deleted file mode 100644
index a8de7c1..0000000
--- a/src/mikuart.rs
+++ /dev/null
@@ -1,703 +0,0 @@
-// mikuart now shipped as module for better code organization
-// all ASCII art were obtained from https://emojicombos.com/miku-ascii-art
-
-use rand::Rng;
-
-pub fn get_miku_art(style: Option<i32>, list: Option<bool>) -> Vec<&'static str> {
-    let mut rng = rand::rng();
-    let list = list.unwrap_or(false);
-    let style = style.unwrap_or(-1);
-    let styles: Vec<Vec<&'static str>> = vec![
-        //MARK: small art
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣷⣀⡤⠤⠤⠤⠤⢤⣄⣀⡀⠀⠀⠀⣀⣀⡀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⣾⣿⣟⡵⠚⠉⠀⠤⠂⠀⠀⠀⠀⠀⠀⠉⠓⠦⣾⣿⣿⣿⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⣴⣿⣿⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⣄⠀⠀⠀⠘⢦⡙⢷⣜⣿⣿⣆⠀⠀⠀",
-            "⠀⠀⢺⣿⣿⡟⠁⠀⢀⠀⠀⡆⠀⠀⠀⠀⠀⠈⢣⡀⠀⠀⠀⠙⡼⡍⡘⣿⣿⣆⠀⠀",
-            "⠀⠀⠀⢹⡟⠀⠀⢀⠇⢀⡼⡇⠀⠀⠀⣤⡀⠀⠀⢱⡀⠀⠀⠀⠸⣿⡴⡘⣿⣿⣆⠀",
-            "⠀⠀⠀⣼⡅⠀⠀⣘⢀⡾⢥⣿⣰⠀⠀⡟⢷⡀⢷⣄⢷⡀⠀⠀⠀⢻⡞⣧⣿⡿⠋⠀",
-            "⠀⠀⢠⡿⡇⠀⠀⣽⣾⣤⣤⣈⢿⠆⠀⡇⠘⠹⣿⡝⢮⣇⠀⠀⠀⢸⣿⣿⡟⢱⠀⠀",
-            "⠀⠀⢸⠀⡏⡇⠀⣿⢱⠿⣿⣻⡝⢿⣄⢳⢐⣶⣾⣷⣾⣿⠀⠀⡇⠘⣿⠉⡄⠸⡀⠀",
-            "⠀⠀⡏⢸⣧⣷⠀⣿⠸⢯⣉⡾⠁⠈⠻⣾⡜⣗⠿⣭⡏⣿⠀⢀⣧⡀⣿⡄⡇⠈⡇⠀",
-            "⠀⢠⠇⠸⢱⡟⣆⣿⣄⠀⠀⠀⠀⠀⠀⠈⠁⠑⠖⠚⠀⣾⠀⣼⣿⠙⠇⡇⠇⠀⢇⠀",
-            "⠀⢸⠀⠀⢸⠀⠘⢾⣿⣗⣦⣄⣀⠰⠤⠄⠀⠀⣀⣠⢴⢧⠾⠿⠃⠀⠀⡇⠀⠀⢸⠀",
-            "⠀⡏⢀⠀⢸⠀⠀⠀⠀⠙⠿⣣⣾⣭⢿⣫⡿⠻⡍⠠⠟⠁⠀⠀⠀⠀⠀⡇⢀⠀⢸⠀",
-            "⢠⠁⢸⠀⢸⠀⠀⠀⠀⢀⣴⣿⣧⢸⢿⠇⣵⣼⣿⡄⠀⠀⠀⠀⠀⠀⠀⡇⡎⠀⠘⡇",
-            "⢸⠀⠸⡄⡇⠀⠀⠀⣠⣾⣿⣿⡏⣸⣸⠈⠀⢹⣿⣿⣆⠀⠀⠀⠀⠀⠀⡿⡇⠀⠀⡇",
-            "⡄⠀⠀⣇⢰⠀⠀⠸⢿⣿⣿⢞⠇⣟⢸⠅⡆⠘⣿⣿⣿⣧⠀⠀⠀⠀⠀⣇⡇⠀⠀⢠",
-            "⢁⢆⠀⠸⣼⠀⠀⠘⠋⢩⣾⣧⣶⣿⣿⣆⣼⣿⣿⣿⣻⠿⡄⠀⠀⠀⠀⣿⠁⠐⠀⢸",
-            "⠘⡌⣆⠀⢻⡆⠀⠀⠀⠘⠫⣟⣿⣿⣿⣿⣿⣻⣯⠟⠉⠋⠁⠀⠀⠀⢠⡏⢀⠷⠀⢸",
-            "⠀⠙⢿⣗⢔⢷⡀⠀⠀⠀⠀⢸⣶⣶⣿⢳⣶⣖⡇⠀⠀⠀⠀⠀⠀⠀⡼⢀⢎⡇⢠⡇",
-            "⠀⠀⠀⠙⠻⠲⠽⠄⠀⠀⠀⠀⣿⣿⣿⢸⣿⣿⡇⠀⠀⠀⠀⠀⢀⣞⢔⣃⣼⡴⠋⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢾⡻⠿⢨⡿⣿⡇⠀⠀⠀⠀⠀⠉⠉⠉⠉⠁⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣾⣿⠷⠒⠛⠉⠛⠓⠦⣤⣶⣳⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣠⠖⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣻⠽⠀⢀⣠⡔⣦⣄⠀⠰⣟⢻⡁⠉⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠸⠉⠙⠲⢷⣄⡈⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⠁⣠⠖⠋⠘⣇⡇⠈⠳⡄⠘⢷⣷⠀⠀⢹⡄⠀⠀⠀⠀⠀⠀⠀",
-            "⠨⠷⣶⡦⢄⡈⠑⢦⡈⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⡿⢡⡼⣓⠁⠀⠀⢿⣿⠒⠢⢽⡄⠀⠸⣧⠀⠀⢻⡀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠉⠙⠒⠯⢤⣽⡀⠉⠲⣄⠀⠀⠀⠀⠀⠀⠀⡼⢹⠇⣾⠻⣁⡟⠀⠀⠀⠻⢾⣉⡾⣷⠠⢐⣿⡆⠂⠀⢳⡀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⠦⡀⠑⢄⠀⠀⢀⣀⡼⢁⣾⣿⡏⠀⠀⢠⠤⣤⣀⡀⠀⠉⠀⢸⣼⣿⣿⣿⣷⠸⡀⠈⢧⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣄⠳⣾⣿⣿⣷⣼⡭⣿⣧⡀⠀⡼⠀⠀⢸⠀⠀⠀⢀⣼⣿⣿⠟⢻⡀⣧⠀⠘⣇⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣇⠀⠀⢸⠀⣀⣠⣾⣿⡟⠁⠀⠈⡇⢸⡄⠀⢹⡆⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⡿⠉⣛⣿⣯⠿⣻⡿⠛⢿⣿⠓⠀⠀⠀⣇⠈⣇⠀⠈⣿⡀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡼⠉⣽⡹⣏⣟⣻⣿⣷⢴⡿⢩⣿⡞⠹⡄⠀⠀⣹⣇⠀⠀⠀⣟⠀⢿⠀⢃⠸⣧⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠃⢰⣯⢳⡝⣦⢻⣿⢏⡾⠁⢸⠀⠷⢶⠿⣿⣿⣿⣿⠀⠀⢀⣏⠰⠌⠀⠸⡐⡽⡄⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡞⠀⣾⢧⡻⣜⡧⠟⠛⣾⠁⢀⡿⠒⠎⢦⢹⣿⣿⣿⣿⣧⠀⢰⡇⠨⢀⡐⠀⡇⣝⣳⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠃⢀⡿⣧⣛⣾⢿⡄⢀⣽⣠⣏⠀⠢⠄⡈⢺⣿⣿⣿⣿⣿⡆⣸⠃⠀⡀⢧⠀⢸⢰⠽⡆",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢠⠊⣹⢧⢯⡽⣮⢿⣿⣿⣿⣿⣧⣀⣤⣴⣿⣿⣯⣿⢿⣿⣿⡿⠀⠁⡀⢸⠆⢸⣹⢚⣷",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣯⡏⠀⣿⣛⡮⣗⠿⣦⣽⠛⠿⣿⣿⣿⣿⣿⢻⣿⣷⣿⣿⣿⣿⢃⡀⠁⡀⢸⢣⠸⡜⣷⢺",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⠀⢸⢸⡿⡼⣭⡻⣵⡿⣯⣙⢚⣧⣴⠒⣋⣡⣴⣟⠳⠴⢿⣿⣾⠀⠠⠀⡼⢣⢸⡕⣻⣿",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡄⢸⡇⠏⣷⡳⡽⢶⡟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠘⠀⣯⡄⠀⠄⣏⣛⢦⠽⣱⣟",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⡘⣿⣄⢹⣳⡽⠋⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠹⣶⠀⢸⢣⡝⢮⡹⣥⡟",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⣼⡹⢾⠏⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠀⠀⠀⠀⠙⢧⣜⡳⣚⢧⢳⡽⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠻⢿⠂⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⠀⠀⠀⠀⠀⢹⢶⡙⣮⠟⠁⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⠿⢛⡿⠿⠿⠋⠀⠀⠀⠀⠀⠀⠀⠀⢸⡧⠟⠁⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣀⣀⠀⠀⣀⡠⠴⠒⠚⠉⠉⠓⠒⠦⣄⣶⠒⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡷⢬⣉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠠⡌⠻⣧⢻⣧⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣖⠗⡋⢹⠀⠀⢰⡄⠀⠀⢸⣷⡀⠀⣠⠽⣆⢼⣇⢻⣸⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡜⣡⣶⢋⡏⠙⢢⣏⣇⠀⠀⠈⣇⡵⡏⠀⠀⢹⡏⢾⣿⠃⢿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⢿⢻⣏⣿⡇⡄⣾⠀⠹⡄⠄⠀⡇⠀⠹⣤⠈⠹⣿⣾⢸⠀⢘⣷⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣯⣿⣽⣿⣷⢸⡗⠦⣄⡹⣼⣄⣿⣴⠛⠹⡄⡇⣿⣿⠾⠚⢹⢿⢽⣽⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣞⣾⣿⢿⣯⢻⢻⡴⠞⠁⠈⠻⣿⣌⡉⠓⣿⣰⡿⠀⠀⠀⠸⡜⡾⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢀⡴⣡⠊⢸⣹⠁⠈⠙⣾⡄⠁⠀⢰⠛⠉⠉⠉⢳⣀⣿⣿⠃⠀⠀⣀⣀⣧⣿⡞⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⣠⠋⡴⠁⠀⠸⢿⣤⣤⣤⣹⣿⣷⣶⣾⣷⣶⣶⣺⣋⣽⣿⣷⠶⠟⠛⠋⢧⠀⠀⠸⡜⣷⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⡜⠁⡰⠁⠀⠀⢠⡿⠀⠀⠀⠉⠉⠉⠙⢻⡟⣹⣿⠃⣿⠋⠁⠀⠀⠀⠀⠀⠸⡄⠀⠀⢣⠹⣧⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⢠⠏⡀⢠⠇⠀⠀⢠⡿⠁⠀⠀⠀⠀⣤⣶⡴⠚⢻⠡⣸⠀⢹⣆⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠸⡄⢻⣇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢀⡏⣼⠁⢸⠀⠀⠀⣾⠃⠀⠀⠀⠀⠀⢻⣿⣧⣀⣬⠋⠁⠀⣠⣿⣶⣆⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠈⣿⡀⠀⠀⠀⠀⠀",
-            "⠀⠀⣸⣸⣿⠀⡇⠀⢰⣸⡟⠀⠀⠀⣀⣠⠴⠚⣟⣻⣧⣯⣗⣤⣾⣿⣿⡿⠋⠀⠀⠀⠀⣸⣤⠀⠀⠀⡇⡆⢻⠃⠀⠀⠀⠀⠀",
-            "⠀⠀⣿⡿⢸⡀⣇⠀⣸⣿⡁⠀⣾⣻⡁⣀⣤⣶⠟⠋⠉⠛⢿⣋⣻⡏⠉⠀⠀⠀⠀⠀⢰⣿⡇⠀⠀⠀⣷⡇⣸⡄⠀⠀⠀⠀⠀",
-            "⠀⠀⠿⠇⠀⢧⢸⠀⣿⡿⠇⠀⠈⠛⠛⠋⠉⠀⠀⠀⠀⠀⡟⠀⣿⠇⠀⠀⠀⠀⠀⢠⣿⣿⡇⠀⠀⣰⡿⣧⣿⠃⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢿⣄⣹⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡇⠀⣿⠀⠀⠀⠀⠀⠀⣸⡿⢸⠁⢠⣾⠋⢰⣿⡏⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠉⠛⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣶⣶⡿⠀⠀⠀⠀⠀⠀⠉⠁⢸⣶⡟⠁⠀⠾⠟⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡖⣉⡬⣷⣦⠶⠶⠞⠙⡦⠖⠒⠒⠒⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⢤⣠⠔⢦⡀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡞⢉⣩⢯⡴⠃⢀⡴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠓⢦⡀⠀⠀⠀⠀⠀⠀⠀⠻⡀⠀⠁⠀⢀⡇⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⡿⠉⠲⣵⠘⡆⠴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢦⡀⠀⠀⣀⣀⣀⠀⠙⣆⠀⡠⠎⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⡤⠞⠓⠓⠲⢄⡘⠃⠹⡄⠀⠀⠀⢀⡀⠀⠀⠀⡀⠀⠀⠀⢀⠀⠀⠈⢳⡀⠹⡄⢀⡇⢀⡞⠀⠀⠈⡏⠁⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⣀⡤⠽⠂⠀⠧⡄⣀⢀⡏⣇⠀⠀⢀⡿⣄⠀⢀⠈⣇⠀⠀⠀⠙⡆⢁⡟⢁⡞⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⣠⠞⠁⠀⠀⠀⠀⠀⠘⢧⡤⠖⢒⠿⡆⠹⡬⠻⣦⡘⢆⠀⡼⠀⣈⡽⠫⣀⠈⡆⠀⠀⠀⠓⡼⢀⡿⠚⠉⠉⢹⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡖⣱⠁⠱⡞⠱⡤⣄⡉⠀⠹⡇⠀⠁⢀⣠⠎⠙⢷⠀⠀⠀⢠⠃⠀⠀⠀⣠⠤⠚⠃⠀⠀⠀⠀⠀⠀",
-            "⠀⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠏⠀⡇⠀⢀⠟⡆⠳⡄⢙⣦⠀⠀⠀⠾⣍⡀⠀⠀⢸⡀⠀⢀⡏⠀⠀⡴⠋⠈⠉⠓⠦⡀⠀⠀⠀⠀⠀",
-            "⢸⠁⢀⡴⠂⠀⠀⠀⠀⡀⠀⡏⠀⢰⢁⡔⠋⠀⢳⠀⠙⡍⢰⠒⠚⡇⠀⠀⠙⠂⠀⣼⠃⣠⡜⠀⠀⡞⠁⠀⠀⠀⠀⠀⠈⠳⡄⠀⠀⠀",
-            "⣧⢞⡏⠀⠀⠀⠀⠀⡼⣇⠀⡇⠀⢸⠎⠀⡤⠖⠒⡇⠀⢳⠈⠓⠚⠁⠀⠀⠀⢀⡤⠿⠋⣰⠃⠀⣜⠁⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀",
-            "⠀⢸⠀⠀⠀⠀⠀⠀⡇⠈⠳⠇⠀⠀⠀⡞⠁⠀⠀⠹⡄⠈⣇⡀⠀⠀⣀⡤⠞⠉⠀⠀⢀⡇⠀⣰⠃⠙⢦⠀⠀⠀⠀⠀⣤⣄⡀⢸⠀⠀",
-            "⠀⢸⡀⠀⠀⠀⠀⠀⡇⠀⠀⠀⢀⣔⣲⠟⠲⣄⣀⡠⠟⢻⢁⣏⡟⢩⡁⢀⡟⠦⣀⣀⣾⣄⣰⠃⠀⠀⠀⠱⡄⠀⠀⠀⠀⡇⠹⠃⠀⠀",
-            "⠀⠀⠑⠦⣄⡀⠀⠀⣧⠀⠀⢀⠏⣷⠃⠀⠀⠀⠉⠳⣄⡞⢯⡘⡖⣆⠳⣼⠀⠀⠉⠳⣴⠃⠉⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀⢳⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠉⠉⠉⠁⠀⠀⢸⠀⠛⠀⠀⠀⠀⠀⢀⣈⡽⣶⡵⠃⠈⠙⠺⣄⠤⠀⠀⠘⢦⡀⠀⠀⠀⠠⠟⠚⡇⠀⠀⢰⡏⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠓⠦⠤⠤⠒⠖⢊⡝⠀⠀⠀⠀⠀⠀⠀⠀⢛⠒⠦⠖⠋⠉⠀⠀⠀⠀⠀⣠⣞⡥⠤⠤⠞⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠤⡯⠤⠤⠤⠤⠤⠤⠤⠤⠤⢼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⣇⠀⣄⠀⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠞⠁⠉⠉⠉⠉⢦⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⡖⠓⠶⢦⢄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⣀⡘⣿⣿⣟⠙⢶⣄⡀⠀⠉⠳⠤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡠⠖⠛⠉⠀⠀⠀⠀⠈⠿⣿⡛⣦⠤⠤⣉⡓⠀⠀⠀⠀⠙⠓⠤⣀⡀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⣶⣶⣤⠖⠁⠀⠀⠀⠀⢀⣀⣤⣄⠀⠀⢿⣴⣿⣿⣶⣤⣍⡓⠶⣤⣀⡀⠀⠀⠀⠉⠑⠒⠤⠄⢀⡀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠏⢩⣿⣧⣼⡁⠀⣀⠀⠀⢠⣤⠀⠈⠙⢯⠳⣆⠀⠹⣝⢻⢿⠛⠁⠉⠲⢌⡉⠙⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠀⣸⣿⠛⠉⠉⠉⢁⠀⠀⠀⠻⠓⢄⠀⠀⠀⠈⠁⠀⠉⢿⣿⣇⠀⠀⠀⠀⠉⠳⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢠⡇⠀⡿⢁⠀⠀⠀⠀⠈⢣⠀⠀⢸⣆⡀⠀⠀⠀⠀⠀⠀⠙⢮⢻⣿⡄⠀⠀⠀⠀⠀⠀⠈⠑⠶⢄⣀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⣼⣡⣫⠏⠀⠀⠀⢀⡏⠳⣄⣎⢇⠙⠛⣦⣤⣀⠀⠀⠀⠈⣧⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠳⠤⣄",
-            "⠀⠀⠀⠀⠀⠀⠀⢰⠃⢠⢻⢣⣿⠀⡀⣤⡄⢸⡇⠀⠈⠙⠾⣦⡀⠸⣿⣿⣿⡶⣦⠀⣿⣼⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈",
-            "⠀⠀⠀⠀⠀⠀⢰⠋⠀⢸⣿⡏⣿⠀⣧⠹⡇⢸⣷⣶⣶⣦⠀⠀⠁⠀⠈⠉⠉⠀⢻⡆⡿⠳⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣰⠃⠀⠀⢸⣿⠀⣿⣧⡹⣆⢻⡀⢿⠊⠻⠿⠀⠀⠀⠀⠀⡀⠀⠀⢠⣧⣧⠀⠙⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⣠⣄⠀⠀⠀",
-            "⠀⠀⠀⢀⡜⠁⠀⠀⠀⠈⣇⠸⠁⡇⠳⣝⢿⣷⡌⢿⣄⠀⠀⠸⢶⣶⣿⣿⠀⢠⢻⡿⠷⢽⣦⣄⡀⠀⠀⠀⠀⢀⣿⣾⠟⠋⠉⠉⠲⡀",
-            "⠀⠀⣠⠋⠀⠀⠀⠀⠀⠀⠏⠀⣸⠀⠀⠈⠓⢿⡝⣄⢻⣟⢤⡤⢄⣙⡷⢏⡴⠃⢸⣀⠀⠀⠀⠀⠀⠀⠀⠀⢘⣳⣿⣣⣴⠶⣤⣲⣄⠀",
-            "⢀⡜⠃⠀⠀⠀⣀⣀⡀⠀⠀⢀⠏⠀⠀⠀⠀⠀⠙⢮⣻⡬⠛⠓⠚⠷⣿⡋⠉⠉⣿⣿⣷⡔⠒⠛⠓⢦⡀⠀⠈⣯⣿⡝⢿⣷⣼⣻⣎⣷",
-            "⠎⠀⠀⠀⠀⠺⡉⠉⠙⠒⢤⣜⣀⣀⣠⣤⣤⣤⣤⣴⣿⣶⣄⠀⠀⠀⠈⢻⡒⠀⣿⣣⣘⣿⣆⠀⠀⠀⠹⣄⢸⣿⣿⣷⡈⢻⣿⣷⡿⣅",
-            "⠀⠀⠀⠀⠀⠀⡉⠓⣢⢤⣄⠀⠈⠉⠉⠙⢿⣿⣿⣿⣿⣯⣿⣷⠀⠀⠀⠀⢳⢦⠉⠉⠳⣌⠛⣝⠲⢤⡀⠈⣾⣿⣿⣿⣿⣦⡙⣿⣷⣿",
-            "⠀⠀⠀⣠⠇⠟⢀⣾⣵⣿⠿⠀⠀⠀⠀⠀⠘⣮⠹⣿⣿⣿⣿⣿⣀⡀⠀⠀⠈⡇⠀⠀⠀⠈⢧⡀⠱⣄⠈⠓⢾⣿⣿⣿⣿⣿⣿⣿⣿⣼",
-            "⠀⢀⣴⠏⠆⢀⣾⣿⡿⠃⠀⢈⠉⠓⠒⠒⠉⠈⢳⡙⣿⣿⡟⠋⠉⠻⣧⣀⠀⣿⠀⠀⠀⠀⠀⠱⡄⠈⠳⣄⠀⢘⣿⣿⣿⣿⣿⣟⣧",
-            "⢀⣿⠏⠀⣠⡾⠛⠉⣀⣀⠀⠀⠑⢜⠢⢤⣀⠀⢈⣧⢻⡟⢧⠀⠀⠀⠀⠹⣆⣿⣷⣄⠀⠀⠀⠀⠹⣦⠀⠘⢦⠘⣿⣿⣿⣿⣿⣿⣿⢿",
-            "⠈⠏⢠⡞⠁⣀⣴⣾⣿⡟⠁⣀⣀⠀⢣⠤⣌⣳⣾⣿⢸⠁⠀⠳⡀⠀⠀⢠⣿⠿⣿⡛⠓⠀⠀⠀⣠⣿⡆⠀⠸⣿⣿⣿⣿⣿⣿⣿⣿⣟",
-            "⠀⠀⠘⠲⠚⢉⣼⡿⠋⢀⣴⣿⣿⡇⠀⣧⣄⠈⠙⠻⣿⠀⠀⠀⠙⢶⣶⣿⣿⡄⠈⠛⢦⣄⣀⠘⠛⣻⡇⠀⢠⡏⣿⣿⣿⣿⣿⣿⣿⣿",
-            "⠀⠀⠀⠀⣰⡟⠹⠁⣠⣾⣁⠘⣿⡀⠀⣿⣿⣿⣷⣦⣾⠀⠀⠀⠀⠀⠙⣏⠿⠹⢦⡀⠀⠀⢀⣴⠾⠉⡇⠀⠸⡇⠈⠹⣿⣿⣿⣿⣿⣿",
-            "⠀⠀⠀⣰⡿⠀⠈⠈⠳⢾⣻⡿⣿⣷⣾⣿⡿⢿⣫⠝⠁⠀⠀⠀⠀⠀⠀⠈⢮⠣⡄⠻⠶⣾⡿⠋⣰⣾⡇⠀⠀⣷⡄⠀⠀⠙⠿⣿⣿⣫",
-            "⠀⠀⢠⣿⠇⠀⠀⠀⠀⠀⠀⠉⠛⠛⠛⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢳⣄⠀⠀⠉⢠⣾⣟⣿⠃⠀⢀⣿⠇⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢈⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⣿⠗⠀⣠⣿⡿⢁⡿⠀⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        //MARK: medium art
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣶⣶⣤⡤⠤⠶⠶⠦⠤⣄⣿⢿⣷⢦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠟⠋⠻⠄⣀⠀⠀⠀⠴⢮⠑⢦⣿⣎⠻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⢡⠞⠀⡘⠀⣿⣷⣄⠀⠀⠈⢷⡀⠻⣿⣆⢸⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡏⢀⠏⡀⢠⢇⠀⢻⠹⣿⣷⠄⣆⠘⣿⣶⣿⡉⡇⢧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠘⡞⡾⡇⡿⠼⢆⠸⡞⣹⡾⣧⡹⡄⢻⣻⣿⡇⢸⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⢰⣧⠀⠋⣷⢶⣮⠓⣿⡅⢿⣿⣷⡘⠘⣿⡿⠁⠀⢇⢻⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣾⣿⣆⠈⢿⡾⣿⡆⠈⠉⠀⠉⠷⡿⡄⣿⡇⠀⢰⡼⡌⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣿⠈⠢⣸⣿⣆⠁⠀⠔⠂⢀⣼⣼⣿⣿⣧⠀⠸⡙⣵⢸⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠃⡀⠀⢸⢿⣿⣿⣶⣾⡯⠗⣿⡾⣥⠉⢻⡀⠀⢇⠙⣇⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡃⢰⠁⠀⡟⠈⣻⢯⣽⣿⣧⣴⠟⣤⡘⡇⠘⡇⠀⠘⡄⠸⡘⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡷⢁⠇⠀⢸⠃⢰⣯⢊⠏⣷⣾⣽⡇⠉⠹⡇⠀⢷⠀⠀⢱⠀⠱⠘⣧⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⠀⡞⠀⠀⡟⣴⣏⣧⠎⢀⠁⢀⣸⣧⣤⣤⣧⠀⢸⠀⠀⠀⢣⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣼⠋⠀⡘⠀⠀⢸⡿⣿⢿⠏⠀⢸⠉⣳⣴⡟⢻⣿⣿⡆⠘⡇⠀⠀⠈⣄⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⡼⠁⠀⣰⠁⠀⢀⡾⡛⢁⣮⡄⡰⣿⠘⠳⡿⡧⠿⠿⣿⣧⠀⡇⠀⠀⠀⠘⣆⠀⠀⠸⣧⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢀⡞⠀⠀⣰⠃⠀⢠⢿⡴⠓⡟⠛⠁⠀⣷⡗⢤⡸⡇⢀⣠⣿⣿⣆⢃⠀⠀⠀⠀⠈⢆⠀⠀⠹⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢠⡟⠁⠀⣰⠃⠀⣴⣥⣾⣧⡾⡇⠀⢀⡼⣷⠿⢀⣽⡇⠈⡟⠏⢿⣿⣿⠀⠀⠀⠀⠀⠘⡀⠀⠀⢹⡀⠀⠀⠀",
-            "⠀⠀⠀⢀⡾⠀⠀⢠⠃⢀⣾⣿⣿⣿⡿⢡⣿⣠⣾⠉⠻⣷⣿⣿⡇⠌⢹⠸⣘⣿⣿⣷⡄⠀⠀⠀⠀⢱⠀⠀⠈⣷⠀⠀⠀",
-            "⠀⠀⠀⡼⠁⠀⠀⡞⡰⠋⠀⠈⣷⣽⡳⢿⣷⣻⣿⠀⣀⣿⡿⣿⡧⠀⠘⡇⢿⢟⣿⣿⣿⡦⠀⠀⠀⠀⢧⠀⣆⠸⡇⠀⠀",
-            "⠀⠀⣸⠁⢀⠀⡸⢸⣥⣀⢀⣼⠟⣿⡏⠙⠒⢲⠽⠭⢵⡞⠊⠉⣿⠀⢀⣼⡈⢾⣿⣿⡿⠁⠀⠱⡀⠀⠘⡆⢸⣆⢻⡀⠀",
-            "⠀⢠⠇⢀⡎⢠⠃⠀⠈⢙⣿⣿⣿⣿⣧⣀⣀⣼⠀⠀⠀⣧⣤⣶⣿⣐⣿⣿⣷⣾⣿⢿⡄⠀⠀⡇⢳⠀⠀⢣⠀⣏⢎⡇⠀",
-            "⠀⠸⢀⣾⠁⡜⠀⠀⠀⠘⠛⡏⠀⢹⢿⡿⣿⡇⠀⠀⠀⢸⡍⣹⢿⣿⡈⠹⠿⠛⠋⠈⡇⠀⡄⠀⠀⠀⠀⠘⠀⠹⡜⣷⠀",
-            "⠀⡇⣜⡇⠀⠃⠀⠀⠀⠀⢀⠁⠀⣾⣾⣿⣿⠇⠀⠀⠀⠈⣧⠙⠿⣿⣧⡀⠀⠀⠀⠀⡇⠀⢇⠀⠀⠀⠀⠀⠀⠰⢇⢸⠀",
-            "⠀⡗⢹⠀⠀⠀⠀⠀⠀⠀⢸⠀⢠⡏⠀⣏⣿⠀⠀⠀⠀⠀⢹⣤⠀⢻⣿⣷⡀⠀⠀⠀⢳⠀⢸⠀⠀⠀⠀⠀⠀⠀⢸⠘⡇",
-            "⢰⡇⣼⠀⠀⠀⠀⠀⠀⠀⣸⠀⡾⡀⢸⣿⣿⡀⠀⠀⠀⠀⠀⣿⠀⠈⢿⣿⣷⡄⠀⠀⢸⠀⠀⡆⠀⠀⠀⠀⠀⠀⣼⡀⡇",
-            "⠘⡇⣿⡄⠀⠀⠀⠀⠀⠀⡏⢠⡇⠁⢸⣿⣿⡇⠀⠀⠀⠀⠀⢹⡇⠀⠘⣧⠻⣿⡄⠀⢸⠀⢰⡇⠀⠀⠀⠀⠀⢀⡟⡇⡇",
-            "⠀⡇⡇⣧⠀⡄⠀⠀⠀⠀⡇⢸⠱⠀⢸⠐⣿⡇⠀⠀⠀⠀⠀⠈⡏⠀⠀⢹⡀⢹⣷⡀⡟⠀⡞⡇⠀⠀⢀⠆⠀⡼⠀⣇⡇",
-            "⠀⢃⡇⠸⡆⢱⠀⠀⠀⠀⡇⣸⠀⠀⣾⡆⢸⣧⠀⠀⠀⠀⠀⠀⢷⡆⠀⠈⣿⠀⣿⣷⡇⣰⠁⡇⠀⣦⠎⠀⣸⠃⢰⣿⠃",
-            "⠀⢸⣿⠀⠹⣆⠣⡀⠀⠀⢻⢿⠀⠀⣿⣤⣼⣿⡄⠀⠀⠀⠀⠀⢸⣧⣤⣴⣿⣡⣾⣿⣷⠁⠀⡇⢠⠏⢀⡼⠃⠀⢸⡟⠀",
-            "⠀⠀⢻⡆⠀⠈⠻⣷⣄⠀⢸⢼⣾⣿⠿⠿⠛⠻⣿⡄⠀⠀⠀⠀⠘⣿⣿⣿⡿⠿⢿⣿⣿⠀⢰⠇⢀⣴⠟⠁⠀⠀⣾⠃⠀",
-            "⠀⠀⠈⠁⠀⠀⠀⠈⠙⠷⣤⣿⣿⣧⣀⣀⠀⠀⢻⣿⠀⠀⠀⠀⢸⠁⣨⡿⠀⢀⣸⣿⠏⠀⣾⡶⠋⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⢿⣾⣷⣴⣿⡿⠀⠀⠀⠀⢺⣿⣯⣀⣶⣾⡿⠋⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠀⠀⠀⠀⠀⠀⠙⠛⠛⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠄⠋⠑⣦⡀⠀⠀⣠⠴⢋⠁⠀⠀⠀⢀⡴⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⢦⡀⠀⢀⣠⠤⠒⠉⠉",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠢⠐⠒⠀⠀⠀⠀⠀⠙⣦⠞⢁⠔⠉⠀⠀⠀⢰⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣞⠉⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⠃⠀⠀⠀⣠⠞⠁⠀⠋⠀⢀⡴⠀⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢢⡀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡷⢀⡾⢁⡞⠁⠀⣠⠞⠁⠔⠋⠀⠀⡜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠱⡀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣇⣸⡵⠋⠀⣠⠞⠁⠀⠀⡄⠀⠀⢀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⡄⠀⣀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡼⠋⣨⠏⢀⣤⠔⠁⠀⠀⢀⡼⠁⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠰⣿",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣇⡼⠉⢀⠞⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⠀⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠟⠁⢠⡟⠀⠀⠀⠀⠀⡘⠁⠀⠀⠀⠐⣿⠀⠀⠀⠀⠀⠀⠀⢀⡿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⣠⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⡀⠀⠀⠀⠀⠀⠀⢸⠁⢻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢀⡟⠀⣰⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠏⢸⡇⠀⠀⠀⠀⠀⠀⢸⠀⠀⢻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⡼⠀⢠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣻⠋⠀⠀⡇⠀⠀⠀⠀⠀⠀⣸⠀⢦⠀⠹⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰",
-            "⠀⠀⠀⠀⠀⠀⡸⠁⢠⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠷⠶⠦⣤⡇⠀⠀⠀⠀⠀⠀⣿⠀⠈⢣⠀⠘⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸",
-            "⠀⠀⠀⠀⠀⣰⠃⢀⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠋⠀⠀⠀⠀⣇⠀⡇⠀⠀⠀⠀⡟⠀⠀⠀⠑⠄⠈⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢰⠃⢀⣼⠃⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡏⠀⠀⠀⠀⠀⢹⣰⣿⡄⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⣀⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠃⠀⠚⠁⢠⡌⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⣷⣿⣷⣶⣦⡀⢸⣏⡏⢷⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠁⠀⠙⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⡾⠀⢨⡇⠀⠀⠀⠀⠀⠀⠀⢰⣿⠋⢡⠉⢻⣿⣿⣿⣦⣹⡇⠸⣆⠀⠀⣇⠀⠀⠀⠀⠀⠀⢀⣠⠄⠈⢳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢰⠇⣀⣿⡇⣄⠀⠀⠀⠀⠀⢸⣿⡟⠀⣼⣿⣿⠟⢿⣿⣿⣿⠇⠀⢻⣆⠀⢸⠀⠀⠀⠀⠀⠶⣉⣠⣶⣾⣿⣿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣿⠀⣿⡿⠁⢿⠀⠀⠀⠀⠀⣼⡟⢷⠀⢻⠻⣇⡀⣸⣿⡿⠁⠀⠀⠀⢻⡀⢸⠀⠀⠀⠀⠀⣶⠿⠿⣿⣿⣿⣿⣿⡿⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⡟⠀⣿⠇⠀⢸⡆⠀⠀⠀⠀⢻⣿⠀⠃⠘⢧⣉⣋⣉⡿⠃⠀⠀⠀⠀⠀⠻⣼⡀⠀⠀⠀⠀⠩⣦⣴⡿⠛⠛⣿⣽⡿⠙⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠁⢸⡟⠀⠰⠸⣇⠀⠀⠀⠀⣾⣿⡄⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠙⠧⠀⠀⠀⠀⠀⣿⢿⣷⣤⣠⡿⣻⠇⠀⣼⢿⣦⣴⡆⠀⠀⠀⠀⠀⠰⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠸⠃⠀⠀⡆⢻⠀⠀⠀⢰⡏⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⠜⠶⣬⣭⣥⡴⠋⠠⠞⠁⣰⣿⣿⣷⡀⠀⠀⠀⠀⢀⡇⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢱⡸⣇⠀⠀⣸⠁⢸⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡿⠉⣿⡿⣧⠀⠀⠀⠀⣽⡅⠀⢇⡀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠇⢻⡇⢀⡏⠀⢸⡏⢻⣄⠀⠀⠀⠀⠀⠀⢠⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⠁⠀⢸⣧⣿⡄⠀⠀⠀⡟⡇⠀⣾⠁⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢷⣾⡇⠀⢸⡇⠀⠙⢷⣄⠀⠀⠀⠀⠈⣏⠉⠉⠓⠒⠤⣤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⠃⠀⠀⣰⣿⣿⣷⡀⠀⢰⠇⡇⢠⡇⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⢀⡀⢀⣸⣟⣿⡀⢸⡇⠀⠀⠀⠉⠳⣦⡀⠀⠀⠈⠳⢤⣤⣤⡴⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⠇⠀⠀⣼⣟⢻⣿⣿⣇⠀⢸⠀⡇⣾⠃⠀⠀",
-            "⠀⠀⠀⢀⣤⠖⠋⠉⠉⠉⠉⠉⠉⠁⠈⠙⢷⣸⣷⠀⠀⢀⣠⡶⠋⠉⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣠⣴⡾⠻⣿⣿⣿⡿⠀⢠⠾⠛⠛⠛⣿⣿⣿⡀⡏⠀⣷⠏⠀⠀⠀",
-            "⠀⠀⢠⠏⢁⠏⠀⠀⣰⡇⠀⠀⢠⡇⠀⠀⡄⠈⢻⣦⣤⣾⠁⠀⠀⠀⠈⠿⣝⠶⣄⣀⠤⠤⠖⣲⠟⠋⠁⠀⠈⣻⢷⣤⣿⣿⣿⠃⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠏⠀⠀⠀⠀",
-            "⠀⠀⡎⢀⣼⠀⠀⢠⡻⠀⠀⢀⣿⠀⠀⢰⠃⠀⢸⠃⠀⢸⡆⠀⠀⠀⠀⠀⠈⠳⣄⠀⣠⠴⠛⠁⠀⠀⠀⠀⢹⠇⡜⠛⠿⠿⣯⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢸⠃⣼⡇⠀⠀⣾⡇⠀⠀⢸⠃⠀⠀⡎⠀⠀⣎⠀⢠⡟⠃⠀⠀⠀⠀⠀⠀⠀⢿⠟⠁⠀⠀⠀⠀⠀⠀⠀⡜⢹⡇⠀⠀⠀⡾⠃⠀⠈⠉⠙⠻⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⣯⣀⣀⣼⡟⠀⠀⣠⠏⠀⠀⣰⠃⠀⣸⠋⣷⣿⠀⠐⠀⠀⠀⠀⠀⠀⢀⣨⣤⡀⠀⠀⠀⣰⠚⠀⠀⠁⠀⣷⠀⠀⠈⠁⠀⠀⠀⠀⠀⠀⠀⠉⢻⣿⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠸⢤⣠⢾⡁⠀⣠⠴⣏⣄⡀⠀⢀⡿⠃⠀⢀⠀⠀⠀⠀⢀⡾⠋⠉⠉⠛⣆⠀⢠⡏⠀⠀⠀⠀⠀⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣧⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠉⠉⠁⠀⠀⠀⠉⠛⣻⠀⠀⠀⠈⠀⢀⣀⠤⢻⠀⠀⠀⠀⠀⣿⡆⠘⠇⠀⠀⠀⠀⠀⠀⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀",
-            "⢀⠀⢀⠀⣀⣀⣀⣀⣀⣼⣀⡀⠀⢠⣀⣀⡀⣈⡅⠀⠀⠀⠀⠀⠈⠀⠀⠈⢷⡀⠀⠀⣠⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⡼⠷⠤⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⢀⡞⡼⠋⠀⠀⣤⣦⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⢿⡟⢟⢻⣍⠉⠙⣿⣿⣿⣶⣿⣿⣿⣿",
-            "⠀⠀⠀⠀⢀⡞⣼⠃⠀⢀⣾⣿⣿⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢤⡙⣷⡄⠈⢣⡻⣿⣿⣿⣿⣿",
-            "⠀⠀⠀⢀⡞⣸⠏⠀⢠⣿⣿⣿⣿⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠈⠛⣿⣶⡀⢳⡝⣿⣿⣿⣿",
-            "⠀⢠⠆⡾⢰⡏⠀⣰⣿⣿⣿⣿⣿⠁⠀⠀⠀⢀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⣀⠀⠀⠈⢿⣷⣼⣿⡄⣿⣿⣿",
-            "⠀⠘⢸⣥⣿⠁⣰⣿⣿⣿⣿⣿⡟⢰⠀⠀⢀⡞⠀⠀⠀⢀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⢿⣷⣄⣠⣾⡟⠙⠻⣿⠹⣿⣷",
-            "⠀⠁⠈⣿⣧⣴⣿⣿⣿⣿⣿⣿⠇⠈⠀⠀⢰⠃⠀⠀⠀⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⣹⣿⣿⣯⣧⡄⠀⠈⢧⠹⣿",
-            "⠀⠀⠀⠉⠈⠻⣿⣿⡟⢻⣿⣿⠀⠀⠀⡄⡎⠀⠀⠀⣼⡟⢷⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡯⣾⠿⠁⠙⢿⣿⡇⠀⠀⠸⣷⡈",
-            "⠀⠀⠀⠀⠀⢠⣿⣿⡇⠸⣿⡏⠀⠀⠀⣇⠃⠀⢠⣾⣿⠃⣿⠠⡄⠀⠀⠀⠀⠀⠀⠀⠀⣠⠖⢸⠁⡇⠀⠀⠀⠁⠀⡇⠀⠀⠀⣿⠀",
-            "⢠⠀⠀⠀⠀⢸⣿⣿⣿⡀⢿⡇⠀⠀⠀⣿⣀⡴⢃⠟⠁⠀⢿⡇⢧⣀⠀⠀⠀⠀⠀⠀⢠⠗⢲⣿⢲⡗⠀⠀⠀⠀⠀⠐⠀⠈⢷⣿⠀",
-            "⡈⠀⠀⠀⠀⣼⣿⣿⡿⢃⢸⡇⡇⠀⠀⢿⠛⠠⠋⠀⠀⠀⠘⣿⣌⢿⠀⠀⠀⡆⠀⢀⡏⢀⡞⣹⡏⢳⠀⠀⠀⠀⠀⠘⠀⢀⠸⠟⠂",
-            "⣿⠀⠀⠀⠀⣿⣿⣿⣿⢸⡆⠃⣇⠀⠀⠸⡤⠷⠶⢶⣴⣶⣄⠈⠛⣎⣇⠀⠀⡇⢀⣾⢁⠞⠀⡿⠁⢹⠀⠀⠀⠀⠀⠀⠀⢸⣦⡀⠀",
-            "⣿⠀⠀⠀⢰⣿⣿⣿⣿⠀⡇⣌⢻⡀⠀⠀⢱⡀⠀⠀⠈⠙⠻⠀⠀⠈⠙⢶⡀⢳⠎⢘⣸⣶⣾⣧⣄⠀⡇⣦⠀⠀⠀⡀⠀⠀⢿⣧⠀",
-            "⣿⠀⠀⠀⢸⣿⡿⣿⣿⡇⢱⠘⣤⣱⡀⠀⠈⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠻⣴⣿⣿⣿⣿⡙⢿⣷⣇⢸⠀⠀⠀⡇⠀⠇⢸⣿⡄",
-            "⣿⠀⠀⠀⢸⣿⡧⣿⣿⣧⠸⡀⢻⡍⠱⡄⠀⠈⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢏⣙⡿⠋⠀⢈⣽⣿⣿⡆⠀⠀⣿⠀⠀⠀⡇⠇",
-            "⢹⡀⠀⠀⢸⣿⡇⢸⡿⣿⡄⡇⠈⢣⠀⠙⡄⠐⡀⠀⠤⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⢠⣾⣟⣿⣿⣹⣄⢠⡿⠀⠀⠀⠀⠀",
-            "⢸⡇⠀⠀⣾⠟⠃⢸⡇⢻⣿⡇⠀⢀⡡⠖⣻⣆⠘⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⢁⣾⣿⠿⠋⣹⢿⣄⠀⠀⠀⠀⠀",
-            "⢸⡇⠀⠀⡍⠀⠀⢸⡇⠈⢿⡷⠞⠁⢀⡼⠋⣿⣷⢤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⡟⢻⣿⡿⠁⣠⣾⡷⠾⢿⡇⠀⠀⠀⠀",
-            "⠘⣷⠀⠀⠀⠀⠀⢸⡷⣶⠏⠀⢀⡴⠋⠀⢀⣿⣿⡀⠙⠢⣀⠀⠀⢀⣀⣀⣤⣴⣶⣿⣿⣿⠃⢰⡟⠁⣰⠟⠁⣠⣴⣿⠀⠀⠀⠀⠀",
-            "⠀⣿⡀⠀⠀⣠⢞⣥⡾⠁⢀⡴⠋⠀⠀⢀⣾⢡⣿⡷⣤⣀⣈⣉⣉⣠⣿⡿⢋⣭⠥⣶⠞⠁⠠⠫⠤⢼⣁⣠⣾⣟⣿⣿⡆⠀⠀⠀⠀",
-            "⠀⣿⡇⠀⢸⡏⢿⡿⠁⠀⠊⠀⠀⠀⠀⡾⢁⣾⠟⠙⠛⠿⠿⠿⢿⣿⢏⡴⠋⢀⣴⠷⠾⠒⡑⠒⠒⠤⣈⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀",
-            "⠀⢹⣿⠀⠸⡇⢸⣉⠓⠲⢤⣄⣀⣀⡤⠖⠋⠀⠀⠀⠀⠀⠀⣼⣿⢋⡞⣡⣴⡟⣹⠀⠀⠀⠀⢉⡶⠄⠈⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀",
-            "⠀⠸⣿⣆⢀⡏⠒⠬⣍⣓⠲⢬⣿⣦⣄⠀⠀⠀⠀⣀⠀⠀⣸⣿⣇⣾⣿⣿⣿⡇⡿⣄⠀⣠⠔⠉⠀⠀⣰⣿⣿⠋⣩⣿⡿⣷⠀⠀⠀",
-            "⠀⠀⣿⣿⣸⣷⡄⠀⠀⢠⣉⠓⢬⡙⢿⣷⣄⠀⠀⠀⠙⢲⣿⣿⣿⣿⣿⣿⣿⢠⡇⠈⡷⢤⣀⡀⢀⣰⡿⣿⣿⣿⠋⠀⡇⢿⠀⠀⠀",
-            "⠀⠀⢸⣿⠏⡾⣿⣦⣄⣀⠙⢿⣶⣽⣦⣝⢿⣷⡀⠀⢀⣿⢿⣿⣿⣿⣿⡿⢿⣾⠗⢀⡇⠀⠀⠉⠉⡝⠀⣿⣿⣿⠀⠀⡇⢸⠀⠀⠀",
-            "⠀⠀⠈⣿⢰⡿⠋⠙⠻⢿⣿⣶⣿⣿⣿⣿⣦⣹⣷⡄⣸⣿⣿⣿⣿⣿⠋⣰⣿⣿⣇⣸⠀⠀⠀⠀⠀⡇⢸⣿⣿⣿⣆⠀⠃⠈⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣤⣤⡤⢤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⡾⠋⢲⡄⠀⠀⠀⠁⠀⠀⠀⠉⠳⣮⠷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⣤⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⠋⠀⠀⠀⠙⣆⠀⢀⣠⣴⣶⣿⣿⣿⣿⣷⣿⣿⣿⡗⠲⠶⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠹⡄⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠁⠀⠀⠀⠀⠀⣸⣿⡿⠟⠛⣩⡴⠋⠁⠈⣻⠛⢧⡉⠛⠷⣄⡀⠉⠛⢦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢱⠀⠀⠀⠀⠀⠀⣠⣾⡟⠛⠦⣤⡀⠀⣠⣾⠟⠋⠀⢠⡾⠋⣀⠀⠀⡼⠁⠀⡆⠹⡄⠀⠈⠳⣅⠀⡀⠙⢧⡀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣤⣶⠆⠀⠀⠀⠀",
-            "⠀⠀⠘⡄⠀⠀⠀⠀⡼⠋⡏⠀⠀⠀⠀⠉⣵⠟⠁⠀⠀⣴⠏⠀⣰⠁⠀⢰⠃⠀⠀⡇⠀⢻⡄⠀⠀⠙⣦⠈⠳⣄⠹⣄⠀⠀⠀⣠⣴⣾⣿⣿⣿⣤⣄⠀⠀⠀⠀",
-            "⠀⠀⠀⣷⠀⠀⠀⢰⠇⢀⣇⠀⠀⠀⢀⡼⠋⠀⣴⠖⠛⣱⠀⣰⠃⠀⡄⢸⠀⢠⠀⡇⠀⠘⣿⡀⠀⠀⠘⣧⠀⠈⢳⣜⣧⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⠄⠀⠀⠀",
-            "⠀⠀⠀⢻⡀⠀⠀⢸⠀⣸⠻⣆⢀⣴⡯⠀⢀⡞⠁⠀⣰⠃⣰⠃⠀⣼⠀⡏⠀⣸⠀⡇⠀⠀⣧⠷⡄⠀⠀⡘⣇⠀⢦⣝⣿⣿⣿⣿⣿⠟⠏⠀⠘⢿⣀⠀⠀⠀",
-            "⠀⠀⠀⢸⡇⠀⠀⡟⢠⡏⠀⣹⣿⡞⠁⢀⡞⠀⠀⣴⠇⣼⡟⠀⢠⠃⢠⣇⠀⣷⠀⡇⠀⠀⣿⠀⢹⠀⠀⠘⡘⣦⠀⠉⢻⣿⣿⣿⣿⣿⠀⠀⠀⠀⣨⣟⠁⠀⠀",
-            "⠀⠀⠀⣼⣿⠀⢰⡇⣼⠁⢸⣿⣿⠃⢀⣾⠀⠀⡼⢹⢱⠃⡇⠀⡼⠀⢸⣿⠀⣿⣄⡇⠀⠀⣿⠀⠈⡇⠀⠀⢣⠙⡆⠀⠘⣿⣿⣿⣿⣷⣷⠒⠚⠋⠁⣹⣷⠀⠀",
-            "⠀⠀⠀⣿⠙⡆⢸⣧⡏⠀⣿⡟⡟⠀⡾⡋⠀⡾⠓⢺⡟⢴⣧⠀⡇⠀⠸⣿⣆⢻⠻⣷⠀⠀⣿⠀⢰⢹⡄⠀⠘⡆⢹⡀⢀⣿⡿⣿⣿⣿⣷⡲⢶⣶⣖⠛⠋⠀⠀",
-            "⠀⠀⠀⣿⠀⣧⢸⣿⠀⢸⣿⣴⠇⡼⠀⣇⡾⠁⠀⢸⡇⠀⡇⢀⡇⠀⠀⣿⡟⢮⣦⣸⣄⠀⣿⠀⢸⡘⣧⠀⠀⣷⠀⣷⠈⣿⣀⣨⡏⠙⢿⠷⣿⣿⡿⠷⣆⠀⠀",
-            "⠀⠀⠀⡿⠀⣿⢸⡏⠀⣼⣿⣿⢀⡇⠀⣿⣷⣿⣶⣾⣗⠀⢹⣼⡇⠀⠀⢸⡇⠈⠻⣝⣿⠻⢾⡄⠈⡇⢻⡀⠀⢻⡄⢹⣾⡏⠙⠿⠟⠻⣿⡷⢽⣿⣦⣀⣼⣷⠄",
-            "⠀⠀⢸⡇⠀⠸⡿⠁⢀⣿⠁⡿⣾⡇⢘⣿⡟⣿⣟⣿⡟⢷⡈⣿⣿⡀⠀⠈⡇⠀⠀⠈⠻⣦⣼⣏⠹⡇⠀⣧⠀⢸⣇⠈⣿⠷⣾⣿⣆⣤⣯⡀⣀⣿⣇⡼⠟⠉⠀",
-            "⠀⠀⢸⠁⠀⠀⡇⠀⢸⣿⠀⣿⣿⣷⡀⡇⠀⣿⢿⡿⠇⠈⠁⠈⢯⣷⡄⠀⣟⣭⣷⣶⣶⣮⣿⡸⣆⣳⠀⣿⠀⠘⣿⠀⣿⣄⣼⡏⠀⣹⣿⣭⡿⠿⠋⠀⠀⠀⠀",
-            "⠀⠀⣿⠀⠀⠀⡇⠀⢸⣿⠀⠸⣿⣯⣷⣳⡀⠘⠛⠋⠀⠀⠀⠀⠀⠀⠙⢦⣇⣾⣿⣿⣿⡎⢿⣗⣹⣷⠀⣿⡇⢠⣿⣤⡇⠠⡿⣿⠋⢹⠂⣿⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⡏⠀⠀⠀⡇⠀⢸⣿⠀⠀⠻⣿⣿⠹⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢧⡻⠟⠻⠇⢈⡟⢻⣷⠀⢁⡇⣼⢿⣿⠂⢰⠇⡟⠀⣸⡆⢸⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢰⡇⠀⠀⠀⡇⠀⠸⣿⠀⠀⠀⠉⣿⣆⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠛⠻⠭⠌⠋⢠⡿⡇⢠⣼⣿⣿⣸⡟⠀⣸⠀⠇⣰⠏⣷⣾⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢸⡇⠀⠀⠀⡇⠀⠀⣿⠀⠀⠀⢀⡇⠘⢦⡀⠀⠀⠠⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣼⡇⢰⣿⣿⡿⢻⠀⢀⡇⢠⡼⠃⠀⣿⣿⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⣸⠁⠀⠀⣸⡷⠿⢦⣽⣀⠀⠀⢸⠁⠀⠀⠹⣦⡀⠀⠀⠉⠉⠉⠉⠁⠀⠀⠀⠀⠀⢀⣠⠾⣿⣿⣠⠟⢡⡟⠀⢸⠀⠘⢀⡾⠁⠀⠀⢿⡏⠀⠀⠀⠀⠀⠀⠀",
-            "⣤⡇⠀⠀⠀⣿⠲⣆⠀⠀⠉⢛⣶⣯⣤⣤⣠⣤⣼⢷⣦⡀⠀⠀⠀⠀⠀⢀⣀⣤⡤⠶⠋⠁⠀⣸⠟⠁⠀⠋⠀⠀⢸⣦⣷⠞⡇⠀⠀⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⣿⠃⠀⠀⢀⣿⡄⢿⠉⢳⣶⢿⣿⣿⣿⣿⣿⡿⠃⢸⣿⠙⠓⠒⠒⠊⠉⢉⡽⢿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣿⡎⢀⡇⠀⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⣿⠀⠀⠀⢸⠙⣧⠘⣿⠭⢥⣸⣿⣿⣿⣿⣿⠃⠀⠀⠻⣧⡀⠀⣀⡤⠞⠋⠀⢸⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⢰⠀⠀⠀⠀⢿⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⡏⠀⠀⠀⡿⡄⡸⡖⢿⣷⣶⣾⣿⣿⣿⣿⡇⠀⠀⠀⣀⣈⣻⡻⠝⠒⠁⠀⠀⣸⣿⣿⣷⣦⣄⡀⠀⠀⠀⠀⠀⠀⢸⡟⠀⠈⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠁⠀⠀⣸⠃⠙⣧⠸⡄⠹⣍⠉⣿⠛⡿⢿⣀⡤⣖⣋⣩⡿⢻⠻⡄⠀⠀⠀⢰⣿⣿⣿⣿⡿⢹⡏⠉⠙⠒⠢⣄⣀⣸⠃⠀⠀⠀⠀⠀⠀⢻⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢠⠏⠀⠀⣹⡀⠙⢦⡉⣿⣿⡾⠁⠀⠀⣀⠝⣿⠋⣀⣈⢧⡹⡖⠀⢀⣿⣿⣿⣿⡿⠃⢰⡷⢤⣀⣀⠀⠀⠙⢿⡆⠀⠀⠀⠀⠀⢰⢸⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢠⡟⠀⢀⠶⢹⠇⢠⡎⠁⣿⣽⠃⠀⠀⠈⠀⠀⢸⣿⡿⠟⠉⠉⠙⢦⠞⣸⣿⡿⠿⣭⣉⠛⢶⡤⣽⣎⠙⡗⠦⣈⣧⠀⠀⠀⠀⠀⢸⡘⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⢀⡞⢀⡴⠃⠀⢸⠀⡞⠀⢸⣟⣿⣄⣀⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠀⠀⠀⡟⢷⠀⠀⡘⡫⣳⣄⢹⡄⣸⠛⢻⢦⣼⣿⡀⠀⡇⠀⠀⠈⣷⢻⠀⠀⠀⠀⠀⠀⠀",
-            "⣾⠐⠋⠀⠀⠀⣾⢸⠁⠀⢸⣽⠁⠀⠩⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣵⣷⣄⣠⣭⠀⢈⣿⣾⣇⡏⠉⢻⠀⠈⢿⠀⠀⡇⠀⠀⠀⣿⡞⣇⠀⠀⠀⠀⠀⠀",
-            "⠋⠀⠀⠀⠀⢀⡇⠘⠀⠀⣿⡇⠀⣀⠀⠀⠊⢳⡀⠀⠀⣀⣀⣀⣀⡀⢰⣯⣸⡋⠁⠻⠟⠑⢿⡟⢻⡙⠀⠀⢸⠀⠀⠈⡇⠀⢹⠀⠀⠀⢸⣷⢻⡀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣾⠁⢰⠀⠀⣿⠁⢺⣿⡧⠀⠀⠐⠹⠞⠉⠁⠀⠀⠊⠉⣿⠻⣿⠿⢶⣿⡦⣴⣾⣧⠏⠀⠀⠀⢸⠐⠀⠀⢧⠀⢸⠀⠀⠀⠈⡟⣏⣇⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢠⣿⣀⡏⠀⠀⣹⡄⠀⠀⠀⠀⠀⠀⠀⠀⢠⣶⣶⠀⠀⢰⢧⣶⣷⣄⣤⣯⠀⣸⢿⡿⠖⣆⠀⠀⢸⠀⣀⡤⣼⠀⢸⡇⠀⠀⠀⢷⢹⣸⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣸⣿⡅⠀⠀⠀⠈⣳⣀⠀⠀⠀⠀⠀⠀⠀⠀⣉⡉⠀⢠⣇⣀⣽⡋⠈⢻⢟⡿⣡⠞⠀⠀⠈⠓⢲⠞⠋⣀⢴⡟⠀⠈⡇⠀⠀⠀⢸⣄⣯⣧⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⢰⣿⣿⣿⣿⡿⠁⠠⢀⣿⡙⣎⠁⠀⢀⠀⣯⠰⠀⡀⠰⢹⡋⢍⢿⣿⡹⢿⣏⢷⢹⠨⣁⠋⡙⢻⣿⣏⣏⠳⠄⠀⢹⠰⡁⢏⡿⣧⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣹⣯⣿⣿⣿⠃⡈⡴⢹⣇⠳⠈⢀⠐⠀⢂⡇⢂⠁⢀⠂⡏⠌⢆⠘⣷⢯⡹⣿⠞⡆⠆⠀⠈⠀⠁⠹⣞⡦⡁⢊⠀⠌⡱⠀⡈⢽⣛⡆⠀⠀⠀",
-            "⠀⠀⠀⠀⣼⣷⣞⣿⠇⡚⣼⠁⣿⢨⡑⠈⡀⠄⠡⣘⡇⢀⠂⠠⢸⠌⠀⠈⡀⠈⢿⡱⢿⣿⡸⡄⠀⠀⠀⠀⠀⠘⣷⠡⢀⠂⢦⠑⠠⠐⢸⣻⡇⠀⠀⠀",
-            "⠀⠀⠀⠀⣿⣿⢾⡟⢬⣱⡏⣴⣏⠖⡠⠁⠄⡈⢰⡱⡇⢀⠂⠡⡍⠀⠀⠀⠴⢄⣈⢿⡜⡿⣕⠲⠀⡀⡠⠔⠒⠉⠸⣗⠄⠂⢱⡘⠠⠁⢂⠿⣽⠀⠀⠀",
-            "⠀⠀⠀⠀⣿⣿⣻⢍⣶⡻⢼⣽⣎⠳⣔⡣⡔⢦⣏⡷⡇⠠⠈⣴⠃⠀⠀⠀⠀⠀⠀⠉⢷⡹⢻⡄⢣⠀⠀⢀⠤⣀⣦⣹⣞⡄⠘⡆⠡⠐⢈⠺⣝⠀⠀⠀",
-            "⠀⠀⠀⠀⣿⣿⡏⡼⣞⡏⣿⣿⡜⣣⢿⣱⢛⡾⣽⣻⡇⠠⢁⣿⣶⣶⣤⣄⡉⠳⡄⠀⠀⠙⡄⠹⡄⡄⠀⣱⡿⠟⠛⠻⣿⡶⡀⣏⠐⡀⣢⠸⣝⡆⠀⠀",
-            "⠀⠀⠀⠀⣿⣿⣱⣻⣽⡇⣿⣷⣙⡞⣧⣏⢯⣿⢷⣻⣧⠐⣸⠛⠉⠉⠉⠛⢿⣦⡀⠀⠀⠀⠀⠀⠙⡴⣰⣿⣶⣷⣦⡀⠘⣿⡄⡧⠐⢠⠙⡖⣭⡇⠀⠀",
-            "⠀⠀⠀⢠⣿⢧⢷⣛⡽⡇⣿⡧⡇⢽⣳⣞⣻⣾⢿⣻⣿⠀⣿⣾⣿⣿⣷⡄⠀⠙⠃⠀⠀⠀⠀⠀⠀⠘⢆⣿⣿⣿⣿⠇⠀⣿⣷⡗⠠⠘⠀⠈⠳⣇⠀⠀",
-            "⠀⠀⠀⢸⣿⢺⣟⡧⡗⣇⣿⣽⡇⢚⣷⣞⣯⣿⣟⣿⢿⣷⡿⣿⣿⣿⡿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠉⠛⠠⠀⢰⣿⣿⡕⢀⠃⠀⠀⠀⠙⠀⠀",
-            "⠀⠀⠀⢸⣯⣟⣿⣳⠇⡇⣿⣿⡇⢘⣷⣿⣿⣿⣻⣯⢿⢿⡇⠁⠉⠋⠁⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠐⠂⠈⢠⣿⣿⣏⠀⠆⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⣾⣿⡽⣾⣭⡇⣏⣿⣿⣷⠀⣿⣿⣿⣿⣿⣳⢿⠘⡏⠀⠀⠀⠂⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣷⠸⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠈⣾⢯⣷⣻⢖⡇⣾⣽⣿⠙⣧⢜⣿⣿⣿⣿⣯⢿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡟⣯⣟⣆⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⣟⡾⣭⣟⡞⡇⣽⣿⣿⠀⠹⡜⣿⣿⣿⣿⣿⣾⠟⠢⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⡀⠀⠀⠀⠀⣀⢾⣟⠧⡏⣿⢻⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⣯⢷⣟⢾⡹⡇⣾⢹⣯⠀⠀⠘⣽⣿⣿⣿⣷⡿⢦⡀⠐⣂⡀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠍⠘⠁⠀⠀⠠⢚⠀⢈⡾⣓⡇⢯⡚⡄⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢀⣯⡿⣏⣾⡱⡇⣿⠠⣿⠀⠀⠀⠈⢾⣿⣿⣿⣿⠈⠻⠿⣿⣿⣑⣆⠠⣀⣤⣶⣶⣶⣶⣶⣄⡀⠔⠁⠀⠀⡆⠠⣟⢸⠄⢳⡁⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢸⣷⡿⣏⢶⣹⢣⣿⠀⢿⠀⠀⠀⠀⠀⢻⣿⣿⣿⠀⠀⠀⢀⡝⠙⠻⣟⠿⢿⣿⣯⣿⣷⣿⠏⠁⠄⡀⠀⠀⣇⠀⢻⣏⠂⢸⡁⣇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⣸⣯⢿⡜⣧⢻⠼⣿⠀⠀⠀⠀⠀⠀⠀⠀⣻⣿⣳⡄⠐⠂⢹⡑⢦⡀⡜⡢⣌⠉⠁⣠⢮⢡⢢⡜⢾⢸⠐⠂⠸⠤⠽⣎⡔⢠⢓⢸⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⣿⣟⡿⡜⣧⢻⣜⡇⡖⠀⠀⠀⠀⠀⡠⠊⠈⠟⣯⠇⠀⠀⡔⢉⠶⡱⣭⢳⡝⣗⣾⡝⣮⢳⢧⡞⢹⢂⠀⠀⠀⠀⠀⠀⠑⢮⡣⠼⡆⠀⠀⠀⠀⠀",
-            "⠀⢠⣿⡞⣽⡝⣮⢹⢜⡆⠁⠀⠀⠀⢠⠊⠀⠀⠀⠀⠹⣇⠀⣰⣿⠻⡘⡵⣩⢷⣫⡽⢧⣻⣜⡯⢏⡔⢌⠎⡆⠀⠀⠀⠀⠀⠀⠀⠙⣆⢧⠀⠀⠀⠀⠀",
-            "⠀⠈⣿⡝⣾⡝⣮⢹⣎⢧⠀⠀⢀⠔⠃⠀⠀⠀⠀⠀⠀⠉⢀⣿⣽⣷⡏⢶⡹⣾⠁⠠⠀⠌⣅⠸⢘⡹⣸⠀⢻⡀⠀⠀⠀⠀⠀⠀⠀⠘⠷⠀⠀⠀⠀⠀",
-            "⠀⢸⣷⢻⣼⡳⣍⢾⣿⢺⡅⠀⠤⠂⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⢾⣷⣻⣷⣿⣿⣜⣡⢞⣰⠓⠷⡤⣥⠗⢸⠈⢧⠀⠀⠀⠀⠀⠀⠀⠀⠈⡑⡀⠀⠀⠀",
-            "⠀⣼⣏⠷⣎⡷⡭⣞⣯⠽⣇⠊⡄⠀⠀⠀⠀⠀⠀⠀⠀⢲⣿⣯⣿⣟⢯⣿⠿⣛⡏⡞⢮⣽⡈⠆⠈⠁⢀⠘⡀⠸⡧⠀⠀⠀⠀⠀⠀⠀⠀⠰⠠⡀⠀⠀",
-            "⠀⣿⣎⠿⣜⣳⣓⣯⣟⢦⠇⡐⠀⠀⠀⠀⠀⠀⡐⡑⣆⣿⡿⣽⡿⠮⠇⠋⠱⢌⣿⣹⢳⡞⠐⠀⠀⠀⠂⠌⡀⠀⢿⣰⢯⡄⠀⠀⠀⠀⠀⠀⣽⣓⡀⠀",
-            "⢸⣽⡞⣽⢫⡷⡭⣿⡾⡇⣰⠀⢀⠀⡀⢀⢀⡠⣢⠃⣻⢿⡽⠟⠁⠀⠀⠀⠀⠈⣷⣯⢷⣻⠀⠀⠀⠀⠈⡔⠠⠀⠸⡿⡰⣞⣄⠀⠀⡀⠀⠀⢩⢞⠑⡄",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⣤⣤⣤⣀⣀⡀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢄⢀⠀⡀⣠⣴⣾⣿⠿⠟⠛⠛⠛⠿⠿⠿⠽⠿⠿⠿⠿⠿⢶⣦⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⡿⡵⣯⣾⣿⣿⠟⠉⢀⣤⠶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⢫⣮⢿⣿⡿⠛⠁⠠⠔⢋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠈⠻⣷⣦⠠⣃⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣾⢟⣵⡿⢻⡿⠋⠀⠀⣠⢴⡾⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠈⢻⣷⣏⢫⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⢸⣿⣠⠋⠀⡠⣪⢞⡵⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣧⡻⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⡙⢾⣿⣸⡟⠁⠀⢠⠞⠁⠋⠀⠀⡴⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣷⡹⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠁⡇⢸⣿⠋⠀⢀⡶⠃⠀⠀⢠⠃⠜⠁⠀⣀⠀⠀⠀⠀⢀⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠨⣿⠏⣿⣇⡀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡏⠀⡄⡼⠁⠀⢀⣾⠁⠀⠀⠀⡜⡸⠀⠀⣰⢻⠀⠀⠀⠀⢸⠉⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣆⠀⠀⠀⠀⠀⢿⢸⣿⢻⢱⡄⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁⢀⡟⠀⢠⢃⣾⠇⠀⠀⠀⢰⠁⠀⠀⣰⢃⢸⡄⡄⠀⠀⢸⢀⠘⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⢸⠀⠀⠀⢸⣾⠃⠈⠈⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡎⢠⠞⠀⡰⠃⣼⠏⠀⠀⠀⠀⡜⠀⠀⢰⠃⠉⠸⡇⣧⠀⠀⢸⠈⢦⠘⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢱⡀⠁⠀⠀⢸⡿⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣵⠃⠀⢰⠁⣼⠏⠀⠀⠀⠀⢀⠇⠀⢠⠟⠒⠒⠴⣷⣿⡀⠀⢸⠂⠀⠱⣄⠻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧⠀⠀⠀⠈⠀⠀⠀⠀⠣⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣠⡾⢋⠀⢀⠇⣸⠏⠀⠀⠀⠀⠀⡸⠄⢀⠎⠀⠀⠀⠀⠸⣇⢣⠀⢸⡄⠀⠀⠈⡴⠞⣆⠀⠀⠀⠀⠀⠀⠀⠀⠘⡆⠀⠀⠀⠀⠀⠀⠀⢰⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⡾⢟⡇⡘⠃⡜⣼⣯⠀⠀⠀⠀⠀⠀⡇⢀⡞⠀⠀⠀⠀⠀⠀⢻⠈⢧⠸⡇⠀⠀⠀⠀⠀⠙⢆⠀⠀⠀⠀⠀⠀⠀⠀⢹⡀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠐⠉⠀⡸⠀⠃⢰⣻⣯⠇⠀⠀⠀⠀⠀⢸⢁⣾⣤⣀⠀⠀⠀⠀⠀⠀⠀⠈⢷⡇⠀⠀⠀⠀⠀⠀⠈⠧⡀⠀⢠⠀⠀⠀⠀⠀⢧⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⢀⣷⢣⠎⠀⠀⠀⠀⠀⠀⢹⡞⠀⠉⠛⠿⣶⣬⡒⠄⠀⠀⠀⠈⠋⠀⠀⠀⣀⡀⠀⣀⣀⣼⣦⡀⢇⠀⠀⠀⠀⠸⣧⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⣼⣯⠏⢀⣀⡀⠀⠀⠀⠀⢸⡇⢰⠿⠿⠿⠟⠛⠛⠃⠀⠀⠀⠀⠀⠀⠀⣯⣴⣾⡿⠛⠛⠉⠉⠳⡞⡆⠀⢀⣀⢰⠻⣆⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⣿⠋⠀⡜⠀⡇⠀⠀⠀⠀⢸⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⠛⠿⢷⣶⠀⡼⠀⠹⣀⣺⠈⡏⠇⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⡏⠀⠜⠁⠀⢀⠃⢰⠃⠀⣰⡆⠀⢸⠉⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢧⣄⣴⠋⢿⡀⢹⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢠⠇⠀⠀⠀⠀⡞⠀⢸⢀⡞⠁⣸⠀⢸⣄⠀⢣⡀⠀⠀⠀⠀⠀⡤⠤⠤⢄⣀⠀⠀⠀⠀⠀⠀⠀⢀⠞⡟⡎⡧⠨⠀⠀⡇⠈⡇⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⢠⠇⢀⣿⠏⠀⡰⢹⠀⢸⠈⠳⣤⣥⣄⣀⣀⣀⡀⠣⡀⠀⢀⠔⠀⠀⠀⠀⠀⣀⡴⠃⣼⡇⢠⠛⡄⠀⠀⢡⠀⢺⠀⠀⠀⠀⠀⠀⢰⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⡞⠀⠀⠀⠀⡼⠀⢸⠃⠀⢠⠃⠀⡆⢸⠀⠀⠈⠉⢻⣿⣿⣿⣿⡇⠈⠉⠁⠀⠀⠀⣠⠶⠾⠧⠄⠐⣻⢠⠃⠀⠱⡀⠀⠘⡄⠈⣆⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣰⣣⠤⠎⠉⠽⠁⠀⠘⠀⡲⠏⠀⠀⢱⢸⠀⠀⠀⠀⠀⠘⠀⣷⢄⠑⠦⠤⠒⢂⣩⡮⡞⠀⠀⠀⠀⢠⣧⠃⠀⠀⠀⢣⠠⠀⠃⠀⠘⠍⠙⢦⠤⣕⠾⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢰⢹⡀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠀⣄⡀⠈⢿⠀⠀⠀⣰⢞⠇⠀⠘⠀⠙⣢⣠⠖⠉⠈⠀⠀⠈⢢⣀⠀⠰⠃⠀⠀⢀⡴⡞⠉⠀⠀⠀⠀⠀⠀⠈⠀⢸⠎⡇⠀⠀⠀⠀",
-            "⠀⠀⠀⢀⣾⣄⢧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣝⠢⡌⠀⠀⢸⣿⡆⠀⠀⠀⠀⢀⡨⠶⢀⡀⠀⣠⢦⡀⣸⣿⠀⠀⠀⣠⢞⣩⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⡼⢱⠀⠀⠀⠀",
-            "⠀⠀⠀⣼⣿⣾⣷⣍⠲⢄⡀⠀⠀⠀⠀⠀⢀⣾⣿⡷⣌⢢⡀⣾⠛⣿⡀⠀⠀⣠⡏⠀⠀⠀⢱⣘⢧⣠⢿⡏⢻⡧⢠⠟⡵⢿⣿⣧⠀⠀⠀⠀⠀⠀⣀⡤⢞⣡⣾⣾⣌⣆⠀⠀⠀",
-            "⠀⠀⢰⣿⣿⣿⣿⣿⣿⣶⣬⡑⠲⢤⣀⣠⣾⣿⣿⠃⠈⢢⢻⡇⠀⠙⠷⠞⠋⠉⢷⠀⠀⢠⡋⠛⠻⠻⠟⠁⠈⣻⢇⠞⠁⣹⣿⣿⣷⣄⣀⠤⠖⣋⣥⣶⣿⣿⣿⣿⣿⣼⡄⠀⠀",
-            "⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣬⣌⣉⠙⠛⠓⠒⠚⣠⠏⠀⠀⠀⠀⠀⠀⢸⠀⠀⢸⡀⠀⠀⠀⠀⠀⠀⢿⡘⠒⠒⠚⠛⠋⣉⣨⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀",
-            "⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣭⣽⠿⣹⠁⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠸⡇⠀⠀⠀⠀⠀⠀⠀⠸⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢧⠀",
-            "⢾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⡴⡏⠀⠀⠀⠀⠀⠀⠀⠀⡟⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠈⣿⡄⠙⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⢇",
-            "⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⢠⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠀⢠⣀⣀⣀⣀⣦⠀⢹⣧⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣮",
-            "⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⠘⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⡇⠀⠀⠉⠉⠉⠉⠁⠀⠀⢿⣶⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿",
-            "⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⠀⠀⢰⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⢀⡤⣢⠟⢁⣴⣾⡿⠋⢉⠱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠑⠒⠦⢄⣀⣴⠟⢡⣠⣼⣿⡿⢳⣄⡀⠀⠀",
-            "⠀⠀⠀⠀⠀⢀⣾⡿⠃⣠⣿⣿⠿⠂⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢲⡿⠋⢰⣾⣿⣿⡟⠀⠀⠈⠙⢆⠀",
-            "⠀⠀⠀⠀⠀⡜⠻⣷⣾⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣁⣰⢸⣿⢻⠟⢀⠀⠀⠀⠀⠀⠁",
-            "⠀⠀⠀⠀⠰⠀⠀⢙⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣯⡀⠀⢃⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢠⠎⠀⠀⠀⠀⠀⠀⣼⠀⢀⠀⠀⠀⠀⠀⢠⣷⡀⠀⠀⠀⠀⡀⠄⠀⠀⠀⠀⢻⣿⣿⣿⣧⠑⠀⣢⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⡰⠃⢀⠄⠀⠀⠀⠀⣼⡿⡆⢸⠀⠀⠀⠀⠀⠈⣿⢷⡄⠀⠀⠀⠱⡀⠰⡀⠀⠀⠈⢿⣿⣿⣿⣧⠀⢸⣧⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠡⢢⠋⠀⠀⠀⠀⣼⡟⠀⣇⢸⡆⠀⠀⠀⡄⠀⢿⠀⢳⡄⠀⠀⠀⢳⠀⢳⠀⠀⠀⠈⣿⣿⣿⣿⣷⣘⡟⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢀⠇⠀⠀⠀⠀⣸⡿⢤⠤⠸⡸⣷⠀⠀⠀⢱⠀⣾⡤⠤⢿⡤⢀⡀⠀⢧⠘⡆⠀⠀⠀⢸⡟⠻⢿⠟⣿⣷⡄⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⡞⠀⠀⠀⠀⢰⡿⢠⠇⠀⠀⢳⣿⢇⠀⠀⠈⡇⣿⡇⠀⠀⠻⣄⠀⠀⠘⡆⡇⠀⠀⠀⠀⣇⢀⡏⠀⣿⡿⣄⠀⠀⠀",
-            "⠀⠀⠀⠀⢰⠁⠀⠀⠀⠀⣿⠁⣄⣀⣀⡀⠈⢿⡜⡄⠀⠀⢹⣿⡇⠐⢄⣀⠘⢧⡀⠀⠹⣿⠀⠀⠀⠀⢸⣿⣷⣶⣿⡇⢹⡇⠀⠀",
-            "⠀⠀⠀⠀⠾⠀⠀⠀⠀⢸⣧⣾⠟⢉⣽⣿⣦⠈⢷⡘⣆⠀⠸⡟⣷⣶⠟⠛⢻⣷⣦⣀⠀⢻⠀⠀⠀⠀⢸⣏⣩⣼⣿⡇⠈⣷⠀⠀",
-            "⠀⠀⠀⠃⠀⠀⠀⠀⠀⣿⡿⠁⠀⣠⣾⣿⣿⠀⠈⢿⠺⡆⠀⣧⢸⠀⠀⢀⣹⣿⣿⣿⣷⣼⣤⠀⠀⠀⢸⣿⣿⣿⣿⠀⠀⣿⠀⠀",
-            "⠀⠀⣠⠄⣀⠀⠀⠀⢠⣿⡇⠀⠀⢻⢻⣟⢿⠀⠀⠈⠣⠈⠓⠾⠀⠀⠀⣿⣿⢿⣿⣿⠘⡇⡞⠀⠀⢠⣾⣿⣿⣿⡏⠀⠀⢹⠀⠀",
-            "⠀⠀⠛⠀⣿⠀⠀⠀⢸⣿⣿⡀⠀⠈⠃⠐⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣄⣐⣠⠏⢠⣿⠁⠀⠀⢸⣿⣿⣿⣿⠀⠀⠀⢸⠀⠀",
-            "⠀⠀⠀⠀⢹⡆⠰⡀⢸⡟⠩⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠃⠀⠀⠀⢸⣿⣿⣿⠟⠀⠀⠀⠘⠀⠀",
-            "⠀⠀⠀⠀⢎⣿⡀⢱⢞⣁⣀⡿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⡏⡼⠀⠀⠀⣾⣿⠋⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠈⠿⠻⡇⠀⠀⠒⠢⢵⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣽⠁⠀⠀⢠⡿⢹⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⡀⠀⠀⠀⠀⠀⠀⡟⣦⡀⠀⠀⠀⠈⠓⢄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣴⢿⡇⠀⠀⡄⣸⣇⣼⣀⣀⣀⠀⠀⠀⠀⠀⠀",
-            "⡀⠀⠀⠀⠀⠀⢰⠇⣿⢸⣦⡀⠀⠀⠀⠀⠈⠲⣄⡀⠀⠀⠀⠀⠀⣀⡤⠒⢉⡴⠃⣸⠀⠀⢰⣿⣿⣿⠃⡤⠊⠁⠉⠑⢄⠀⠀⠀",
-            "⡇⠀⠀⠀⠀⠀⢸⠀⣿⣾⣿⢿⠲⣄⠀⠀⠀⠀⠘⠟⣦⣤⣴⡒⠉⢀⡠⠖⠉⠀⣠⠃⠀⣠⣿⣿⡿⠁⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢸⠀⣿⠛⢿⠈⢢⠏⠀⠀⠀⠀⠀⣰⣏⣀⣿⠗⠊⠁⠀⠀⣠⣾⠃⢀⡴⠿⠛⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢸⢀⠇⠀⠈⢠⠃⠀⠀⠀⠀⠀⢰⠟⠁⠀⢹⢇⠀⣀⠴⠊⡱⠥⠔⠋⠀⠀⢰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢸⡟⠀⢀⡴⠁⠀⠀⠀⠀⠀⢠⡟⠀⠀⣰⢿⡘⣾⡅⠀⠀⠀⠀⢀⠄⠀⢠⠏⢀⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢸⠀⣰⣿⠀⠀⠀⠀⠀⠀⢠⣿⠃⢀⡾⡇⠘⠻⡿⢷⡀⠀⠀⠒⠁⠀⢠⠏⢀⠏⣸⠃⢻⠏⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⣧⣾⣹⣿⠀⠀⠀⠀⠀⢠⠏⢉⠀⡞⣰⡇⠀⣴⣥⠞⢷⠀⠀⠀⠀⣠⠎⠀⠸⣶⠋⣠⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣤⣄⣤⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⣄⣄⣠⣤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⣿⣿⢿⣿⣿⣿⣿⡢⠀⠀⠀⠀⣀⣄⣤⣶⣶⣿⣿⠶⠶⠷⢶⣾⣿⣷⣦⣶⣄⣄⢀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⢿⣿⣯⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢀⣾⣿⡿⣽⣿⣿⣿⡽⣟⣿⣷⣤⣶⡿⠿⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠙⠻⠿⣾⣦⣤⣾⣿⡿⣯⣿⣿⣿⣯⣟⣿⣷⣆⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢠⣿⣿⡿⣽⣿⣿⣿⣿⣿⣽⣾⠿⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⢿⣿⣽⣿⣿⠿⣿⣿⣾⡽⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣠⣿⣿⡿⣽⣿⡿⠛⢻⣷⡿⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣷⣶⣷⠿⢿⣿⣿⡽⣿⣿⣦⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣰⣿⣿⡿⣽⣿⣿⢁⣴⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣷⣄⢀⢻⣷⣿⣽⣻⣿⣖⡀⠀⠀⠀⠀",
-            "⠀⠀⠀⣼⣿⣿⢿⣽⣿⡿⣡⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢗⢆⠀⠀⠀⠀⠀⠀⠀⠀⠈⢿⣷⡊⢿⣿⣷⣯⢿⣿⣖⡀⠀⠀⠀",
-            "⠀⠀⠀⢼⣿⣟⣿⣟⣿⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢛⢣⡀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣤⣿⣿⣟⣿⣿⣿⠇⠀⠀⠀",
-            "⠀⠀⠀⠀⢹⣿⣷⣿⣽⣿⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡸⡅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢣⡙⡄⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣳⣿⣿⣿⠁⠀⠀⠀⠀",
-            "⠀⠀⠀⢀⣾⡿⠈⢹⣿⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠄⠀⠀⣇⠃⠀⠀⠀⠀⠀⠀⣼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢳⡘⡄⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⠟⢇⠘⣿⣇⠀⠀⠀⠀",
-            "⠀⠀⠀⣼⣿⠃⠀⣾⣿⠁⣰⠁⠀⠀⠀⠀⠀⠀⠀⡾⠀⠀⣰⣿⣆⠀⠀⠀⠀⠀⠀⡏⡆⠀⠀⠀⢳⡀⠀⠀⠀⢀⠘⣆⠹⡀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡏⠼⡀⢹⣷⡆⠀⠀⠀",
-            "⠀⠀⢠⣿⡇⠀⢠⣿⣏⣴⡇⠀⠀⠀⠀⠀⠀⢀⣸⡃⠀⣰⡿⠹⣿⡄⠀⠀⠀⠀⠀⣿⣿⡆⠀⠀⠀⢿⣦⡀⠀⠀⣆⢹⢰⣧⡀⠀⠀⠀⠀⠀⠀⠀⢻⣿⢂⡇⠈⣿⣷⠀⠀⠀",
-            "⠀⠀⣾⡿⠀⠀⢸⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⣿⣿⠁⣰⡿⠁⠀⢹⣷⡀⠀⠀⠀⢀⣿⡿⢿⣦⠀⠀⠈⣿⣿⣄⠀⢸⠞⡬⣿⡇⠀⠀⠀⠀⠀⠀⠀⢸⣿⡆⢣⠀⢸⣿⡆⠀⠀",
-            "⠀⢠⣿⠇⠀⠀⢸⠿⣿⡿⠀⠀⠀⠀⠀⠀⠀⣿⣗⣰⣿⠁⠀⠀⠀⢻⣷⡀⠀⠀⢠⢿⣷⠈⠻⣷⣄⠀⠘⣿⣿⣧⡀⡇⡒⣿⡇⠀⠀⠀⠀⢠⡄⠀⠸⣿⡇⣹⠀⠀⣿⣧⠀⠀",
-            "⠀⣼⣿⠀⠀⠀⢎⢲⣿⠇⠀⣰⠀⠀⠀⠀⠀⣿⣷⣿⠃⠀⠀⠀⠀⠀⠹⣷⡀⠀⠀⣿⣿⠀⠀⠈⠻⢿⣦⣜⣿⣟⢿⣶⡡⣿⡷⠀⠀⠀⠀⢸⣱⠀⠀⣿⣗⢸⠀⠀⢹⣯⡄⠀",
-            "⠀⣾⡇⠀⠀⠀⢘⣾⡿⠀⢰⣹⠀⠀⠀⠀⠀⣿⣿⡟⠀⠀⠀⠀⠀⠀⠀⠙⢿⣆⠀⢻⣿⡀⠀⠀⠀⠀⠉⠛⠿⢿⠎⠻⣿⣿⣟⠀⠀⠀⠀⢸⣤⣧⠀⢻⣿⣈⠀⠀⠘⣿⡇⠀",
-            "⠈⣿⠃⠀⠀⠀⢸⣿⢃⣤⣿⣿⣇⠀⠀⠀⠀⢿⣿⠁⠀⠀⠀⠀⣀⡀⠀⠀⠈⠻⣷⣬⣿⣇⠀⠀⠀⢀⣀⠀⠀⠀⠀⠀⠈⢻⡏⠀⠀⠀⠀⣿⣿⣿⣶⣼⣿⣦⠀⠀⠀⣿⡷⠀",
-            "⢰⣿⠀⠀⠀⠀⢿⣿⣿⣿⣿⡽⣿⣆⠀⠀⠀⢸⣿⠀⠀⠀⠀⢸⣑⣚⡆⠀⠀⠀⠈⠙⠿⣿⠄⠀⢰⡫⢜⡇⠀⠀⠀⠀⠀⣿⡇⠀⠀⠀⣸⣿⣟⣾⣿⣿⠿⡏⠀⠀⠀⢸⣧⠀",
-            "⢸⣿⠀⠀⠀⠀⠘⣼⣿⢾⣿⣿⡽⣿⣆⠀⠀⠈⣿⡇⠀⠀⠀⠈⠶⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠳⠽⠃⠀⠀⠀⠀⠀⣿⠇⠀⠀⣰⣿⡿⣾⣿⣽⣿⢲⠁⠀⠀⠀⢸⣿⠀",
-            "⢸⣿⠀⠀⠀⠀⠀⠹⣿⣾⠻⣿⣿⡽⣿⣦⡀⠀⢹⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀      ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠀⠀⣴⣿⣿⣽⣿⢽⣿⣏⠆⠀⠀⠀⠀⠀⣿⡃",
-            "⢸⣿⠀⠀⠀⢦⡀⠀⢻⣿⡄⠙⢻⣿⣽⣿⣿⣦⡈⢿⣇⠀⠀⠀⠀⠀⠀⠀       ⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⠇⣠⣾⣿⣿⣿⠋⠁⣼⣿⠋⠀⣠⡏⠀⠀⠀⣿⡆",
-            "⠸⣿⠀⠀⠀⠀⠙⢗⠤⣻⣯⡄⠀⠙⢛⣿⣿⣿⣿⣾⣿⣷⣶⣤⣤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣠⣤⣶⣾⣿⣿⣿⡟⠋⠀⠉⢁⣠⣾⡿⣁⠤⡺⠎⠀⠀⠀⠀⣿⡇",
-            "⠀⣿⡄⠀⠀⠀⠀⠀⠉⠒⠽⠿⣿⣴⣴⣿⣿⣽⣿⣽⣻⢏⡈⠉⠙⠛⠿⠻⠻⠿⠿⠿⠿⠿⠿⠿⠻⠿⠟⠛⠋⠉⠛⠟⣋⣥⣤⣶⣾⣿⠿⠟⠛⠑⠒⠋⠀⠀⠀⠀⠀⢀⣿⠀",
-            "⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⣿⣿⣾⣿⣿⣿⣿⣿⣾⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣿⡟⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀",
-            "⠀⣻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣉⠙⠛⠿⣿⣤⣀⣈⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣐⣿⠟⠉⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀",
-            "⠀⣿⣿⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠳⡢⢌⠹⣿⡿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⢋⠴⡲⠝⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠄⢸⡿⡇⠀",
-            "⠀⠘⣿⣧⠈⠳⡤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣑⣹⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⡏⠖⠉⠀⣀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠋⣠⣿⡟⠀⠀",
-            "⠀⠀⠐⢿⣷⡀⠈⠓⠽⢒⣒⣐⣂⣒⠒⠒⠐⠢⠌⣓⣢⣄⡈⢺⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣡⣴⣮⣝⣐⠓⠚⠨⠽⠂⣖⣂⣖⡒⠭⠓⠉⣀⣴⣿⠉⠀⠀⠀",
-            "⠀⠀⠀⠈⠻⢿⣷⣄⡀⠀⠀⠀⠀⢀⣀⣤⣴⣾⣿⠿⠿⠿⠿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠿⠟⠛⠛⠛⠻⢿⣷⣦⣤⣀⣀⣀⣀⣀⣠⣴⣾⡿⠋⠁⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠙⠻⠿⣿⡿⢿⣿⠿⠿⠋⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠻⠿⠻⠛⠿⠛⠋⠁⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⢤⣤⠤⠀⢤⣠⠤⠒⠒⠒⡒⠛⢛⠛⠛⠒⠢⠤⣀⡀⠀⠀⠀⠀⠀⣀⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠴⠒⠉⢀⡴⠋⠀⠀⠀⠀⠀⠄⣀⠀⠀⠈⠉⠒⢽⡢⣄⠀⢤⡀⠉⠲⣄⠰⣾⣟⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠊⠁⠀⠀⣴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⠀⠀⠀⠉⠪⠳⡄⠉⠢⡀⠈⢷⣿⣿⢾⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⡠⠋⠀⠀⢀⡴⡞⠁⠀⠀⠀⠀⢸⠁⠀⠀⠀⠀⠀⠀⠈⠃⠀⡄⠀⠀⠐⢜⢆⠀⠑⡄⠀⣿⣿⣟⣿⣿⣿⠛⠉⠛⠛⠳⣦⡀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢀⠞⠁⠀⢀⣴⠏⢰⠃⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡆⠀⠀⠈⢞⣆⠀⠈⢆⠸⣿⣿⢾⣿⣿⡂⠀⠀⠀⠀⠀⠻⣆⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⠟⠀⢀⣠⣿⠃⢀⡇⠀⠀⠀⠀⠀⠀⣼⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⠀⠀⠀⠸⡼⡄⠀⠘⣇⢿⣿⣟⣿⣿⣧⠀⠀⠀⠀⠀⠀⠸⡄⠀⠀⠀⠀",
-            "⠀⠀⠀⢠⠏⠀⢠⠣⣰⠃⢀⠞⡇⠀⠀⠀⠀⠀⠀⡧⠘⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣇⠀⠀⠀⢹⢳⠀⠀⢹⡞⣿⣿⣞⣿⣿⣆⠀⠄⠀⠀⠀⠀⠙⡄⠀⠀⠀",
-            "⠀⠀⢀⠏⠀⣠⠣⢱⠃⠀⠈⢸⡇⠀⠀⠀⠀⠀⠀⢹⠀⠀⠹⣤⠀⠐⢤⠀⠀⠀⠀⠀⣿⡀⠀⠀⠀⡟⡇⠀⠀⣿⣸⣿⣿⡽⣿⣿⣄⠀⠀⠀⠀⠀⠀⢹⡄⠀⠀",
-            "⠀⠀⡞⠀⣰⠃⢆⡏⠀⠐⢀⡟⢱⡀⠠⡀⠀⠀⠀⢸⡆⠀⠀⠈⠳⣄⠀⠑⡄⠀⠀⠀⢸⡇⠀⠀⠀⢹⢳⠀⡀⢻⣶⢻⣿⣿⢿⣿⣿⣄⠀⠀⠀⠀⠀⠀⢣⠀⠀",
-            "⠀⢸⠃⢰⠇⢸⢸⠃⠀⣠⡾⠀⠀⢧⠀⢱⠀⠀⠀⠀⡇⠀⠀⠀⠀⠈⠳⢄⡈⠂⠀⠀⣸⡃⠀⠀⠀⢸⢸⠀⢣⣼⣿⡏⣿⣿⡿⠿⠟⢻⡄⠀⠀⠀⠀⠀⠘⡄⠀",
-            "⠀⡏⢀⣿⠀⡏⣿⠀⢀⣿⣃⣀⣀⣀⣳⡳⣀⠀⠀⠀⢻⠀⠀⠒⠒⠶⠖⠒⠓⢦⣀⠀⢱⠃⠀⠀⠀⠠⡼⠀⢸⣿⣿⣏⢾⠁⠀⠀⠀⠸⣧⠀⠀⠀⠀⠀⠀⢡⠀",
-            "⢰⠇⡾⣿⠀⠃⣿⠀⢸⡏⠉⠈⢉⣩⣩⣟⣿⣧⡀⠃⠘⡇⠀⠀⠀⠠⣲⣮⣤⣤⣽⣿⡚⠀⠀⠀⢀⠘⡇⠀⣿⣿⣿⣯⢸⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⡄",
-            "⢸⢰⠇⣿⠀⠀⢹⡀⢸⡇⣠⣶⣿⣿⣿⣷⣽⠻⣗⢆⢠⢻⡀⠀⢠⣾⠿⣿⣿⣿⣿⠿⣇⠀⠀⠠⠀⣾⠃⢰⣿⢻⣿⣿⣿⣶⣤⠄⠀⠀⢿⡀⠀⠀⠀⠀⠀⠀⢃",
-            "⣼⡎⠀⣿⠀⠀⣎⣇⢼⡿⣿⠉⣯⣽⣿⣿⡞⠁⠈⠻⣝⢯⣧⡀⠀⠸⣿⢿⣿⣿⣿⠀⢘⣇⠀⠀⢰⡏⠀⣾⡟⢸⣿⣿⡿⡿⢿⠀⠀⠀⢸⡆⠀⠀⠀⠀⠀⠀⠸",
-            "⢻⠃⠀⢹⠀⠀⠸⣞⢿⣿⡙⠄⠻⠿⠿⠿⠇⠀⠀⠀⠀⠉⠹⣦⠀⠀⠈⠉⠉⠁⠀⠀⠈⢸⡄⠐⡞⠀⣼⣿⠁⣸⣿⣿⣿⣿⡏⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀",
-            "⠈⠀⠀⠘⡇⠠⠀⣿⠈⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡿⠁⣼⣿⠃⠀⣿⡿⣽⣿⣿⠇⠀⠀⠀⠘⣿⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢿⠀⠀⣾⣇⢻⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣃⣾⣿⣿⠀⢰⣿⡿⣽⣿⣿⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢸⡆⠀⣿⣿⣌⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⢀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣼⠟⢡⡟⣿⡿⢀⣿⣿⣿⣿⣿⡏⠀⠀⠀⠀⠀⢻⡀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢸⣇⠌⠿⣿⣷⣞⢻⣧⡀⠀⠀⠀⠀⠿⠗⠶⠒⠛⠃⠀⠀⠀⠀⠀⠀⢀⡰⣻⡟⢠⣾⣿⡿⡷⠿⠿⢿⣿⡿⠿⠃⠀⠀⠀⠀⠀⢸⡁⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣼⢻⣌⠀⠛⣿⣿⣶⢽⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⣾⠿⣠⣿⠋⠁⠘⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⡇⠀⢿⠀⡃⢽⣿⣿⣦⣽⣿⣿⡖⢤⡀⠀⠀⠀⠀⠀⠀⣠⠤⠖⠋⠁⢰⣯⣿⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⡇⠀⠀⢰⠁⠚⣿⣿⣿⠛⣿⣿⡇⠀⠈⠑⢢⣤⣤⡖⠋⠀⠀⠀⠀⣤⣾⣿⢻⡟⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⢸⠇⠀⠀⡘⢌⡱⢽⣞⡿⠀⣻⢿⡇⠀⠀⢀⣼⣥⡀⠀⠀⣠⡤⠒⠋⠉⠉⣿⠀⠈⠈⠙⠻⢦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⣼⠀⠀⠀⡘⠤⡹⢸⣯⡇⠀⣿⢸⡇⠀⠀⢼⠁⡀⣩⣷⣯⡁⠀⠀⠀⠀⢄⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⡟⠀⠀⠀⢘⠠⣝⠢⢿⡇⠀⣟⢸⡗⠀⠀⡞⠐⣾⠟⠅⠈⢷⣄⠀⠀⠀⠀⠈⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢀⠇⠀⠀⠐⠨⢐⢣⡑⢾⡇⠀⡿⢸⣏⢀⡼⢠⣾⣿⠁⠀⢀⣠⣿⣆⠀⠀⢀⡈⠁⢙⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠂⠀⠀⠀⠀",
-            "⠀⠀⢸⠀⠀⠀⠀⡍⢢⢃⡜⣹⡇⠀⡏⣼⠟⠉⣰⣿⡿⣿⣤⣤⣔⡿⠀⠹⣧⠐⠧⠋⣠⣾⠟⠛⠷⠤⠤⠒⠒⠒⠤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠸⡇⠀⠀⠀⠀⠀",
-            "⠀⠀⡞⠀⠀⠀⠠⣐⣢⡧⠼⠿⠧⠴⢿⠃⣠⣾⠟⠋⢀⡟⠀⠀⣸⠃⠀⠀⠙⢷⣆⣾⡟⣻⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠲⣄⠀⠀⠀⠀⠀⠀⡇⠀⠂⠀⠀⠀",
-            "⠀⢠⡇⠀⠀⣠⠞⠉⠀⠀⠀⢀⣠⢢⣷⠾⠋⠁⠀⢀⡞⠀⠀⠀⡏⠀⠀⠀⠀⠀⠉⠉⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢦⠀⠀⠀⠀⠀⣿⠀⠀⡀⠀⠀",
-            "⠀⢸⠀⢠⠞⠁⠀⠀⠀⠀⢀⣾⢃⠎⠀⡀⡀⢀⢠⠞⠀⠀⠀⢰⠇⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣇⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠦⣄⣠⠴⠒⠒⠉⠒⠶⣄⡏⣶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣠⡞⣡⠀⢠⡀⠀⢦⡀⢹⣷⣼⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡿⠁⣿⠟⣷⣿⢦⡈⣇⠀⢻⣿⣈⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⡇⣶⣻⣀⠘⣿⣀⣹⣿⣰⣼⡟⣯⠟⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡇⣿⡿⠿⠋⠉⠋⠛⢿⣿⣿⡇⠈⢦⡸⣾⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡇⠛⣷⣄⠀⠀⠀⠀⣸⠟⠃⠉⠀⠈⢷⣩⡻⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠹⡄⠈⠙⠒⢤⣴⣾⠉⠁⣀⡀⠀⠀⠀⠹⣟⢮⡳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⠀⣿⠀⣀⣴⣿⡏⣀⡬⠟⠁⠈⣆⠀⠀⠀⠘⢧⡉⢿⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡿⣿⠀⢻⣫⠉⣽⡟⠉⡅⢀⣆⠀⢠⣿⠀⠀⠀⠀⠀⠹⣦⡉⠻⢦⡀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢗⣿⢀⡷⠁⣸⡿⠁⠀⠀⢸⣿⠃⣄⣈⡆⠀⠀⠀⠀⠀⠈⠫⣱⠦⣌⡓⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣇⣾⣿⢟⡇⢀⣿⡇⠀⢀⣰⢸⡌⢿⣿⢻⡟⣃⠀⠀⠀⠰⡂⠠⠌⠲⢤⣙⣻⠛⠓⠶⢦⡤⣄⣀⡀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⣻⣿⠏⣾⠃⢸⢽⡇⠀⡏⠁⡶⠁⠈⣿⣎⡷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⠒⠶⢤⣀⠈⠻⣄⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⣿⠟⠁⡼⠀⣿⠀⡟⢸⡇⢰⠃⢸⠇⠀⠀⢹⣷⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣷⣄⠘⣧⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣾⠟⠋⠀⣠⡼⢁⣼⣿⢠⣧⢾⡇⠘⡀⠸⡇⠀⠀⠘⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡉⠚⢧⠹⣷⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠖⢋⣽⡿⠥⠖⠚⠉⢁⣴⣾⣿⠃⢈⠀⢸⠇⠀⠁⠀⢳⡀⠀⠀⣿⣿⣽⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠀⠀⠘⢧⡇⠀",
-            "⠀⠀⠀⠀⠀⠀⣀⣤⣾⠛⠁⣠⡼⠋⠁⠀⢀⣀⢀⣴⣿⣿⠟⠁⠀⠀⣷⠋⠂⠀⠀⠀⠀⠳⡀⠀⢹⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡿⠀⠀⠀⢸⠧⠀",
-            "⠀⠀⢀⡠⠖⠋⣩⠶⢋⡴⠋⠁⠀⠀⠿⣭⡿⣿⠿⠟⢉⣷⣄⠀⢀⣼⣿⡄⠀⠀⠀⠀⠀⢀⣹⠄⠀⢹⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠐⡧",
-            "⠀⠀⣸⣄⣴⣛⣡⠞⠋⠀⠀⠀⠀⠀⠀⠀⣭⣤⣴⣾⣿⣿⣿⣷⣿⣿⣿⣷⣤⣴⣶⣾⣿⣿⣿⣆⠀⢈⣿⣷⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢑",
-            "⠀⠰⣏⡿⢫⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣹⠿⠿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⢀",
-            "⠀⢀⣿⡵⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⣿⣿⣿⣿⣿⣿⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⢀⡜⠀⠀⠀⠀⠀⠀⢀⠎",
-            "⢠⢸⡟⠹⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡧⠤⢙⠛⠋⠛⠛⠿⠿⢿⡟⠛⠉⠁⠀⠀⠀⠀⠀⠠⠐⠀⠀⠀⠀⠀⠀⠀⢀⡼⢀⠀⠄⠀⠀⡀⡀⠀⠀",
-            "⢸⣎⡇⠀⠳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢷⠀⡀⢰⡅⠀⠀⠀⠀⠀⡝⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⢋⠞⠀⢠⣮⠎⠀⠀⠀",
-            "⠀⢿⣷⠀⠀⠈⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣶⣿⣇⠀⠀⠀⠀⣰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠋⣠⠋⢀⣴⠟⠁⠀⠀⠀⠀",
-            "⠀⠘⣏⢧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⢹⣻⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⢡⠞⣁⣴⠟⠁⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠸⡄⠳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠳⢄⡀⠀⠀⠘⣿⣿⡯⢶⢧⣿⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⢁⣴⠿⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠹⡄⠙⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⠈⢿⣿⡯⣝⣾⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⡯⢖⡿⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠹⡄⠀⠑⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢻⣿⣿⣽⣿⡇⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⢴⣶⠿⠋⠁⣰⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠘⢦⡀⠀⠙⠢⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣻⢿⣿⡍⠑⠒⠒⣒⣾⣷⠿⠛⣋⡵⠚⠁⠀⣠⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠙⠢⣄⡀⠀⠙⠓⠒⠀⠀⣀⡀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⣿⣷⡚⠛⠉⠁⠀⠀⠐⠋⢀⡀⢀⡤⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠙⠋⠛⠛⣹⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠛⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣻⣿⣿⣿⣿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⢿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⡏⠸⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⠁⠀⢹⣿⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⡏⠀⠀⠈⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⠀⠀⠀⠀⢼⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⠀⠀⠀⠀⣼⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠰⣿⣿⣿⠀⠀⠀⢀⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⡆⠀⠀⣾⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣷⠀⠀⠸⣿⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣿⣿⣿⣻⡇⠀⠀⠈⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⣿⣟⠟⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠒⠒⠢⣴⣿⣿⣷⠤⠄⠀⠀⠤⠤⠠⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠋⢀⠀⠀⢀⡿⠛⠋⠀⠀⢀⠀⠀⠀⠀⠀⠀⠈⠑⠢⡀⢀⣴⣿⣿⡦⠤⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣤⡟⣇⠔⠉⠓⠂⣤⣴⢯⡿⠤⣴⣧⣀⣀⠀⠀⠀⡀⣸⣿⣿⠋⠀⠀⠀⠀⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⡝⢠⣧⠐⢂⣿⣿⣿⣎⣼⡏⣿⣿⣳⣷⣹⡏⣥⠉⢱⣿⣿⠇⡆⣠⣄⠀⠀⣌⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⢁⢿⣟⣆⢼⢸⡿⠁⢴⡏⡅⣿⣏⡮⠘⣸⣿⢼⣿⣶⣿⣿⣦⡷⡟⠙⣶⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢸⣾⢿⣼⡌⣿⡷⠛⢶⡇⠣⡟⢻⡶⠻⠻⣆⣾⡇⣿⣿⣿⣿⡇⠀⠀⠏⢳⣿⣿⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡏⣿⣜⣿⣷⢸⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠟⣯⣧⣿⣿⡟⣿⡇⠀⠀⠀⣸⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⠘⢧⣻⣿⣿⠀⠀⠀⠠⠄⢄⠠⠀⠀⠀⣼⣿⣿⣿⡿⠃⣿⢹⠀⠀⠀⡟⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⡆⠀⣿⣿⣿⣶⣤⣀⠀⠀⠀⠀⢀⣠⣼⣿⣿⣿⣿⠃⠀⣹⠈⠀⠀⢰⢻⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡖⡇⠀⣿⢿⣿⣿⣿⣿⣿⡖⠒⢚⡭⣾⣿⣿⣿⡀⠀⠀⠀⢸⢀⠀⠀⣞⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⣷⠀⢻⣿⣿⡿⠋⢙⢿⠳⣀⣠⣴⣿⣿⡟⠚⠓⠢⡀⠀⢸⢹⢀⡀⣿⣿⣿⣿⣾⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⢠⡘⣿⣿⠀⠀⢸⢸⢠⠛⢿⣿⢻⣿⠀⠀⠀⠀⢻⡄⢸⣸⢸⠇⣿⣿⣿⣿⣿⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⢞⣿⡿⣿⠘⣇⢻⣿⡄⠀⣹⠈⢿⣤⡟⠻⠟⢸⠀⠀⠀⠀⢸⠃⢸⣼⢻⢰⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⣿⣷⠿⠋⢡⣿⠀⣿⠈⣿⣇⠀⢸⠀⠀⠛⡇⠀⠀⠸⢦⠀⠸⠶⣿⠀⢸⣼⡇⡿⣾⣿⣿⣿⠈⠻⣿⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⣾⡿⠛⠉⠁⠀⠀⣼⠋⠀⢣⢧⠈⣿⣠⡇⠀⢘⠀⡗⣮⣽⣇⣿⣤⣤⣤⣿⠀⣿⣿⢸⡇⣿⣿⣿⣿⡆⠀⠙⢿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣳⡏⠀⠀⠀⠀⠀⢠⣧⡇⠀⠸⣾⡄⢻⣿⣿⣿⣿⡀⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⣿⢿⣼⣶⣿⣿⣿⣿⣧⠀⠀⠈⢿⣿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣇⠀⠀⠀⠀⢀⠞⣿⠁⠀⣷⣷⣧⠸⣿⣿⣿⣿⣇⠸⣿⣿⣿⣿⣿⣿⣿⣇⠀⡟⡌⠉⠏⣿⣿⣿⣿⣾⢇⠀⠀⠈⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠻⣦⡀⠀⢀⢎⡼⣿⡄⠀⢹⣧⢿⠀⣿⣿⣿⣧⣹⠀⣿⣿⣿⣿⣿⣿⣿⣿⣄⣧⠁⡇⣰⣿⣿⣿⣿⣿⣿⡄⠀⠀⢸⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠺⣦⢞⡾⢁⣿⠁⠀⢸⣻⣟⡇⢹⣿⣿⣿⣿⡆⡏⣿⡌⣿⣿⣿⣿⡇⢻⡼⢰⣷⣟⣿⣿⡟⠻⣿⣿⣿⣄⡀⣸⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣫⡾⠀⡼⡏⠀⠀⠀⠙⣿⡇⢸⣿⣿⣿⣿⣷⣧⠸⣿⣿⣿⣿⣿⣷⣾⡇⢸⣿⣄⡿⣿⣿⣦⠈⢿⣿⣿⣿⣷⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢮⣿⠃⡰⣻⡇⠀⠀⠀⠀⣿⣿⠘⣿⣿⣿⣿⣿⡿⠃⢻⣿⣿⣿⣿⣿⢙⠁⠈⣿⣿⢹⠹⣿⣿⣷⠛⢿⣿⡿⣾⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡾⢻⣿⡰⣱⣿⠃⠀⠀⢠⠸⣿⡇⢠⣿⣿⣿⣿⣿⣿⠀⢸⣿⣿⣿⣿⣿⣴⡀⠀⢱⡻⡜⣧⣿⣿⣿⣦⢼⣽⠿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢇⡸⠋⢠⣿⡟⠀⣼⠀⡼⡇⣿⡇⣸⣿⣿⣿⣿⣿⣿⡆⢸⣿⣿⣿⣿⣿⣧⡇⠀⠀⠹⣿⣽⣿⣿⣾⣿⣟⡇⠀⢸⣿⣿⣷⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠴⠋⠀⣰⣿⡿⠁⢼⠍⣼⣻⢱⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣸⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠙⢿⣿⣿⣿⡇⢀⠇⠀⣿⣿⣿⣿⣿⣿⣷⣄⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⡀⠤⣤⣶⡿⢛⣵⡶⢋⣴⣿⠟⣠⡾⢃⣼⠟⣫⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣧⠙⢦⣄⠘⣿⣿⣟⡀⣜⣀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⢀⢔⣭⣶⣿⣿⢥⣾⠟⠋⣰⣿⣿⣿⠞⣫⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠻⣷⣮⣿⣦⡹⠀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠀⠀⠀⠀⠀",
-            "⠀⠀⢠⣻⣿⣿⣿⣿⢞⣋⣤⣴⢿⡻⣯⣿⣵⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⡀⠙⠻⠿⣿⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠘⣿⢸⣿⣿⣿⣟⠿⣹⣶⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⢄⣀⡈⠉⠀⠂⠀⠉⠉⠛⠛⢿⣤⣤⣤⣄⣀⡀⠀",
-            "⠀⠀⠀⠈⠛⢿⣿⣿⣡⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⢿⣾⣎⠻⣿⣿⣿⣿⣿⣿⣿⡿⣿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⣞⣭⠍⠓⠒⣒⣒⣲⣶⣶⣿⠟⠛⠛⣉⣿⣿⠆",
-            "⢠⣶⣾⣿⣿⣛⡛⠛⢛⣻⣿⣿⣿⣿⣟⣿⣯⡉⠁⠀⠀⠀⠀⠙⠿⠽⣾⢽⡿⠝⠺⢝⡇⠀⢜⡩⠖⠋⡿⣿⣿⢿⡿⣚⠷⠚⠈⠙⢿⣷⡀⠉⠙⠛⠒⠒⠛⠛⠛⠋⠁⠀⠀⠸⠟⠉⠁⠀",
-            "⢀⣙⣛⣛⣯⣿⡿⢶⢽⡟⠛⠛⠉⠉⠉⠙⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠒⠁⠀⠊⠃⠀⠉⠀⢠⣤⡴⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠉⠉⠉⠉⠁⠀⠀⠉⠛⠛⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        //MARK: large art
-        vec![
-            "⠀⠠⢄⢠⢲⣒⠧⡐⢄⢢⠰⢠⠄⡀⠰⢢⠔⡢⠔⡢⢄⠀⠆⡴⡰⢠⠤⡀⠐⠹⢶⣒⢖⢢⢖⡰⢂⠦⡤⡀⠠⡀⠀⠲⢒⡔⣢⠔⡰⢠⠄⢢⡐⢠⢂⡔⢠⠄⡄⠂⡄⠠⢀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢈⠱⡌⢢⢯⡝⢢⡉⢦⡑⢎⡡⢎⡐⠈⣇⢮⢱⡹⣰⣉⠦⠘⢰⢻⣦⠳⣱⠀⢀⠈⢻⣿⣔⡧⣽⢩⣎⡵⣩⡤⠐⢆⠀⠈⠑⠃⠞⢱⠣⡝⡴⣈⠇⢦⡘⢆⠎⡔⡡⢂⠅⠢⢌⠠⢁⠈⠄⠂⠁⠠⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢠⠣⡜⢣⡛⡌⠧⣜⡡⢚⠥⣚⠤⣊⠄⢺⣬⠳⡼⣱⢎⡼⡀⠀⠑⣾⣧⡳⣍⠀⠣⢄⠘⢿⣾⣵⣻⣜⣷⣣⢿⡵⡈⢧⡀⠃⠜⣠⢂⢄⡉⠐⠹⣌⠧⣘⡍⡜⢢⡱⠌⣌⠑⡠⠒⡈⠄⢂⠡⠈⠄⡐⠀⡈⠀⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⢄⡳⡜⢧⡽⣖⡳⣬⢳⡝⣮⣜⡱⢆⠢⢹⣎⡿⡵⢯⣞⡵⡃⢈⣆⠐⢿⣽⡚⣥⠘⣦⡁⠈⢻⣯⣿⢾⣭⣟⣯⢿⣵⡈⢷⡄⢡⠂⡄⠈⠘⠕⣆⣀⠘⠐⠌⡐⠃⠤⠑⡠⠊⠄⡑⠠⠈⠄⠂⢁⠠⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⣌⡳⣝⢧⣿⣻⣷⣭⢗⣻⢶⣭⢳⣍⢎⠰⣿⣻⡟⣿⢯⣷⡁⢠⢿⣧⡈⢳⣿⡳⠆⢹⣿⣅⡂⢹⣿⢿⣾⣟⣾⡿⣾⣷⠘⣿⡄⠳⣌⢆⠀⠀⠀⠈⠳⣦⡀⠀⠈⠀⠀⠀⠐⠀⠀⠀⠁⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢢⣟⣼⢻⣷⣿⣷⡿⣿⣽⣳⣯⢷⣎⡎⡄⣿⣷⣿⢿⣻⢾⠁⣸⠘⣿⣷⡄⠻⣧⡟⠀⣿⣿⣦⡀⠙⣿⣿⡾⣿⣽⣿⣽⣆⢸⣿⡄⠹⣞⡕⡀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⣹⢾⡽⣻⣿⣾⡿⣿⣷⣻⣷⢯⣿⢶⡹⠄⣿⣿⢾⣿⢿⣻⠀⣷⡂⣿⣿⣿⠄⠹⣿⣃⠈⣉⣉⣉⣀⠙⣷⣿⢿⣽⣾⣟⣿⡀⢿⣷⡀⠛⣿⣮⣆⠀⠀⠀⠀⠀⠙⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢫⣿⣽⣻⣷⡿⣿⣿⡿⣽⡿⣿⣾⢯⡟⡆⣹⣿⡿⣯⣿⡏⢘⡮⠓⠉⣁⣤⣴⣆⠹⣷⠈⣿⣿⣿⣿⡄⠙⣿⣿⢯⣿⣾⢿⣇⢸⣿⣷⠀⠱⢾⣻⣧⡀⠀⠀⠀⠀⠀⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢸⣷⡿⣽⣾⢿⣿⣷⣿⢿⣻⣿⢾⡿⣝⠦⢹⣿⣟⣿⣷⠁⢁⣤⣶⣿⣿⣿⣿⣿⣧⠸⡆⢻⣿⣿⣿⣯⣃⠸⣿⡿⣯⣿⡿⣿⠀⣿⣿⡆⠀⠈⠳⣟⣷⡄⠀⠀⠀⠀⠀⠈⢣⡀⠀⠀⠀⢀⠀⠀⠀⠀⡈⠐⠀⠂⠀⠀⠀⠀⠀⠀⠀",
-            "⡇⢿⣟⣿⣽⡿⣷⣿⣯⣿⣿⣽⣿⣻⡽⢎⢸⣿⣿⣽⡞⢰⣟⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠘⣿⠻⣿⡟⢁⣆⠹⣿⣟⣷⣿⢿⡇⣿⢿⣿⠀⠀⠀⠙⢯⣿⣆⠀⠀⠂⠀⠀⠀⠱⡀⠀⠀⠀⠀⠀⠀⠀⠄⡀⢀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⣿⡸⣿⣏⣿⣹⣿⣷⣿⢿⣾⡿⣾⣿⣹⠇⣸⣿⣷⣿⠁⣾⣿⣿⣿⣿⣿⡿⣁⣿⣿⡿⠇⠀⠀⠀⠀⠀⠉⠏⠀⢹⣿⣏⣿⣿⡇⢹⣿⣿⡇⠀⠀⠀⠀⢿⣹⣇⠀⠀⠀⠆⠀⠀⢱⠀⠀⠀⠀⢀⠀⠰⠆⡀⠀⠀⠀⠀⠰⠀⠀⠀⠀",
-            "⢿⣧⢻⣿⣽⣿⣳⣿⣯⣿⣯⣿⣟⣷⣯⠃⣿⣿⣽⡏⣰⣿⣿⣿⣿⡿⢋⣴⡿⠛⠁⣠⣤⠤⠶⠾⠶⣶⣦⣄⠈⠈⣿⣯⣿⣾⡇⢸⣿⣟⣧⠘⣁⠀⠀⠀⠙⣿⣆⠀⠄⠀⠀⠄⠀⢡⠀⠀⠴⠀⠠⠘⡐⡆⠘⠄⡀⠀⠄⠐⠀⠀⠀",
-            "⡞⣿⡎⢿⣾⣻⣽⣷⡿⣽⣾⣯⣿⣻⡼⠃⣿⣟⡾⢠⣿⣿⣿⣿⠟⣱⡿⠋⠀⣠⡾⠋⠀⠀⢀⠀⠀⠀⠉⠻⣷⣄⠸⣿⡷⣿⣇⢸⣿⡿⣿⡄⢯⢄⣀⠀⠀⠈⢻⣦⠀⠀⠁⠀⠀⠀⢂⠀⠂⠀⠀⠄⡑⡀⠀⠁⠒⠀⠊⢐⠀⠀⠀",
-            "⣷⡘⣿⡜⣿⣻⣽⣾⢿⣟⣷⣿⣳⡿⣍⢣⣿⡿⢀⣿⣿⣿⣿⣿⣾⡟⠱⠀⣴⡽⠁⠀⠀⠆⣐⣬⣐⠀⠀⠀⠙⣿⡆⢻⣟⣿⡇⢸⣿⣿⢿⡇⠈⠀⣿⣿⡄⠀⠀⠙⣷⡀⠈⠀⠀⠀⠈⢀⣀⠀⠀⢠⠐⠃⠚⠀⠀⠀⠔⢈⠀⠀⠒",
-            "⠿⠇⠘⣿⡘⢿⣯⡿⣟⣯⣿⢾⡿⣽⢣⢸⣿⢁⣾⣿⣿⣿⣿⣿⣿⣧⠆⠀⣿⣿⣾⣷⣆⢈⡿⣞⣟⣷⡄⠀⠀⠘⣷⠸⣿⣯⡇⢸⣿⣯⣿⡇⢸⠀⢹⣿⣿⡀⠀⠀⠈⢻⣄⠀⠂⠈⠀⠘⢽⠀⠀⠠⢉⢦⠰⠀⡀⠄⣀⠨⠀⠀⠀",
-            "⠀⣴⣧⠘⣿⡌⢿⣟⣿⢯⣿⣟⡿⣝⠆⡿⠃⣼⣿⣿⣿⣿⣿⣿⣿⣿⣸⠈⣿⣿⣿⣿⡿⠀⠹⣯⣛⣯⡆⢸⣯⣄⠙⠀⣿⣟⡇⣾⣿⣽⡿⡇⠘⠁⠀⠻⣿⡇⠀⠀⠄⠀⠹⣆⠀⠀⠀⠀⠈⠜⠁⠀⠨⠠⢉⠔⡁⠊⠄⡘⠀⠀⠈",
-            "⠀⢻⣿⣧⡘⣧⠆⢻⣯⣿⣻⣾⢿⡱⢲⢃⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⣿⣿⣷⡀⠀⠀⣶⣌⡙⠓⢂⣼⣿⠟⣀⡅⢻⣿⠀⣿⣽⣾⣿⠃⠀⣀⣀⣰⣿⡇⢰⠀⠀⠀⡀⠈⢧⡀⠀⠀⠀⠀⠀⠀⠀⠁⢂⠐⠠⢁⠂⠄⠐⠀⠀",
-            "⡩⠀⢿⣿⣷⡈⢟⡄⢹⡿⣽⣛⣮⠃⢡⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣄⠸⣿⣿⣿⣿⣿⡿⢋⣼⣿⡇⢸⡇⢰⣿⣯⣷⣿⠀⠀⢿⣿⣿⣿⠆⠈⢱⠀⠀⢀⠀⠈⠳⡀⠀⠀⠃⠀⠐⠱⠚⠲⠞⠳⠦⠈⠀⠀⠀⠤",
-            "⡱⢁⠘⣿⣿⣿⡄⠙⠄⡉⢻⡿⣅⠀⢺⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⠻⢿⣷⣌⠻⠿⠟⣫⣴⣿⣿⣿⡇⢸⠃⠈⣿⣽⣷⡇⠀⠀⢸⣿⡾⠟⠀⠀⠈⢆⠀⠀⠀⠄⠀⠱⡄⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⣱⠩⡀⠸⣿⡍⠀⣀⠀⠀⠈⢻⠖⠀⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣶⣶⣾⣿⣿⣿⣿⣿⣿⠇⡛⡰⢈⣿⣻⣾⠁⠀⠀⠉⠁⠀⠀⠀⠀⠀⠈⠆⠀⠀⠀⠀⠀⠘⢆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⣇⠣⠜⡀⢠⡅⠀⣿⣷⡄⢀⢀⢇⣦⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠂⢁⡏⢸⣟⡞⡟⠀⠀⠀⠀⠀⠀⢀⣀⣤⣶⣾⣿⣿⣿⣶⣤⡀⠀⠈⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠸⣹⡐⠡⠀⢠⠀⣿⣿⠿⠆⠀⢞⡦⢯⠐⣦⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣸⡇⣸⢯⡿⠁⠀⠀⠀⢀⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠀⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠑⢌⣃⠂⠀⠣⣹⣿⣦⠀⠀⣦⡈⠃⠀⡁⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⣰⣿⠃⣼⢯⠓⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀⠡⠀⠀⠀⠠⡄⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢍⡀⠀⠙⢟⣿⣷⣄⠻⣿⡿⠃⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⣯⡜⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠄⠀⠀⠡⣤⣬⣥⣤⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠠⢘⠶⠁⠀⠀⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⡠⠁⠬⠁⠀⠀⠀⠀⠀⠀⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀⠁⢂⠐⡀⠄",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠁⡴⠋⠀⠁⠀⠀⠀⠀⢰⡇⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠆",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡁⠉⢙⣿⣿⣿⣿⣿⣿⣿⣿⠟⠠⠮⠁⠀⠀⠀⠀⠀⠀⠀⣾⣷⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣶⣯⣿⣿⣿⣿⣿⣿⠟⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⡇⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⣠⣾⠀⢂⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⢂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠿⠿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⣿⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⣰⣿⣿⠄⠡⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠲⠖⠢⠀⢌⡉⠙⠛⠛⠛⠛⠛⣁⠤⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⢀⣼⣿⣿⣿⣿⣿⣇⠀⠀⠸⣿⣿⣿⣿⣿⣿⣿⡿⠁⢸⡿⣿⣿⠀⠈⠡⠀⠀⠰⢄⠢⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢸⡏⢹⣷⠀⢀⠀⠀⢎⣱⢹⡸⢈⡹⡎⣀⠀⠀⢀⠀⠀⠀⠀⢀⣿⡿⣿⣏⣿⣹⣏⣿⠀⠀⠀⢿⣷⣿⣹⣿⣹⡿⠁⣶⠈⢸⢷⡏⢀⠀⠁⠀⠀⢾⣆⢉⡆⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠸⣤⡑⢨⢇⠲⡩⢆⡣⢄⡀⢂⡀⣠⣼⢿⡷⡿⣯⣟⣷⣻⢯⡿⡇⠀⠀⠸⣧⢿⣽⣾⠏⢁⣾⣻⠀⢈⠻⠀⣞⣧⢦⡄⢸⠢⠁⠀⠈⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⢀⠡⢈⠡⠒⠀⠀⠐⢻⠳⢮⡶⣜⢦⣣⡤⣤⣤⠟⣗⣏⡾⣵⣻⣞⣞⣳⢯⣟⢳⣇⠀⠄⠀⢷⣋⣷⣋⢤⡟⣾⢝⠂⠠⠀⢘⡳⣬⠞⣅⠘⠂⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠁⠂⠄⢃⠢⢑⢂⡀⠀⠈⣟⡱⣚⢬⠗⣣⠝⣦⢫⠞⡭⣞⡱⢧⡳⣍⢾⡱⣞⢎⣧⢳⠀⠀⠀⢈⠵⣣⢟⢮⢽⡸⠋⠀⢰⣙⠀⢹⣊⠽⣜⠲⡄⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⢁⠘⡨⠄⡊⠔⡂⡔⠀⠀⢎⠱⣘⠪⡹⢡⠛⠴⠋⡞⣱⢣⡝⢬⡓⡭⢎⡵⣌⢏⠶⣩⠇⢈⢠⠈⡞⡵⢎⡳⢎⡑⠁⠀⡸⣜⠀⢠⠓⠞⡬⡱⡈⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⢂⠡⢂⠥⡉⢔⡈⠆⢀⠀⠈⠄⠣⢡⢃⠹⡈⠣⠜⢂⢣⠚⡥⡱⡙⡜⢦⡙⢎⡱⢃⠆⠈⠀⠀⡜⡱⢎⡕⠊⢀⠌⠀⠰⡘⡄⠀⢐⠎⢥⠓⡡⠂⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠰⢁⠂⠀⠀⠀⠀⠠⢀⠀⠁⠂⠜⢠⢃⡌⠀⢂⠄⠀⠀⠀⠊⠐⠨⠁⡜⠈⠢⢁⠢⠡⢱⠘⠤⣉⠦⠱⣉⠆⠀⠀⠀⡸⢑⢎⠈⠠⠌⠀⠀⢒⠱⡘⠄⠈⡜⢢⠉⠔⠁⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠀⠀⠀⠀⠀⠐⠀⡀⢂⠐⠠⡀⠄⡀⠈⠂⠈⠘⡄⢣⢁⡀⠠⠐⠂⠀⠀⠁⠂⠀⠃⠂⠁⠂⠐⠄⠃⠐⠂⠀⠀⠀⠡⠋⠀⠌⠂⠀⠀⡈⠆⢂⠱⠀⡈⠔⢂⠉⡄⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠀⠈⠄⠐⠈⠄⡁⢂⠐⢀⠈⠐⠤⢈⠱⠀⡔⠠⡀⠄⡀⣀⠂⠡⠌⢂⠡⠒⠰⡀⠄⡀⢀⠠⢀⢂⠉⠀⠀⢀⠂⡘⠠⡁⠀⡐⠈⠔⡈⠰⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠄⠂⠁⠠⠈⠐⠠⠀⠄⡀⠂⡀⠄⡀⢀⠀⠁⠐⠁⠐⠈⠐⡀⠌⠡⠘⠠⢁⠊⠡⠐⡡⠈⠄⢂⠁⠂⠀⠀⠀⠂⠐⠁⠂⠀⠐⢀⠁⠂⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⡈⢀⠡⠀⠀⢁⠀⠂⠐⠀⠂⠁⢀⠂⠐⢤⠄⡀⠈⠠⠁⠂⠄⡈⠄⠁⡀⠁⠀⠂⠀⠀⠀⠀⠀⠄⠀⠀⡀⠐⠈⠀⠠⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣴⢿⠶⢦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⡴⠛⠁⠀⢸⣶⠀⣿⣂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠖⠋⠁⠀⠀⠀⠀⠀⣘⡷⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠞⠋⠀⠀⠀⠀⠀⠀⣀⡴⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠖⠋⠀⠀⠀⠀⠀⠀⣠⡴⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⢀⣠⠖⠋⠀⠀⠀⠀⠀⠀⣤⣴⣛⣁⣀⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣧⣄⠀⠀⠀⠀⢀⡴⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠈⠉⠉⠉⠉⠉⠉⠙⠛⠓⠒⠶⠦⢤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢳⡈⠙⠲⣤⡞⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⢦⣹⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⣴⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⡴⣴⠴⣴⢤⣴⢤⣤⣤⣤⣤⣤⣄⣀⣀⣀⣹⣼⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠁⠀⠀⠀⠀⠀⠀⢀⣤⠖⠛⠛⠚⠒⠒⠦⠶⠤⠤⠴⠤⠴⠒⠒⠒⠲⠤⢤⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⠀⢀⣠⠴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⠢⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠉⠀⠀⠀⠀⠀⠀⢀⣶⣿⣷⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠷⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⠀⣠⠶⠋⠁⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣌⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⠀⣀⣴⠚⠉⠀⠀⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠈⢳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠋⠀⠀⠀⠀⢀⣠⠾⣿⣾⡇⠀⠀⢀⡼⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣼⡶⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠙⣆⠀⠀⠀⠀⠀⠹⣄⠀⢀⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣰⠏⠀⠀⠀⠀⣠⣴⣿⢷⣿⠟⠃⠀⠀⢀⣾⠁⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⣹⠃⠀⠀⠀⠀⠀⠀⠀⣾⡇⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⠸⣄⡞⢁⣬⠙⢳⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⡟⠛⣲⡞⠁⠀⠀⢀⣠⡾⠛⠉⣠⡟⠃⠀⠀⠀⢠⡞⠁⠀⠘⢦⡀⠀⠀⠀⢀⡼⠁⢰⠇⠀⠀⠀⠀⠀⠀⠀⣸⠛⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣆⠀⠀⠀⠀⢀⡟⢀⣾⠏⣠⠻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⡟⠀⢹⣾⠃⠀⠀⣀⣴⡟⠛⢶⣶⡾⠃⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠈⢳⡄⠀⣰⠏⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⢀⡏⠀⢹⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⣻⡄⠀⠀⠀⡞⢀⣾⡟⢠⠃⢘⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡏⠉⣷⠀⠀⣙⣿⠶⠾⢿⣵⡙⣧⢰⡟⠁⠀⠀⠀⠀⠀⡼⠁⠀⠀⠀⠀⠀⠀⢹⣞⡃⠀⠀⠀⡿⠀⠀⠀⠀⠀⠀⠀⣾⠁⠀⠀⢷⡀⠀⠀⠀⣀⣤⠾⠂⠀⠚⣧⠀⠀⡼⢁⣾⡟⣰⠓⠒⠒⠿⢶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣸⣇⠀⠈⠷⣤⡟⠁⠀⠀⠀⠉⠐⣿⡞⠀⠀⠀⣠⡦⠀⢰⠇⠀⠀⠀⠀⠀⠀⢠⡞⠙⢧⡀⠀⢰⡇⠀⠀⠀⠀⠀⠀⢠⡏⠀⠀⠀⠘⣧⣠⠴⠚⠉⠀⠀⠀⠀⠀⣿⠀⣰⠃⣾⡟⣲⠃⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡏⠙⣦⡀⢰⡟⠀⠀⢀⡄⠀⠀⢸⡿⠀⢀⣰⡎⢹⠁⠀⢾⠀⠀⠀⠐⠻⣤⣠⠟⠀⠀⠈⠻⠄⠺⣇⠀⠀⠀⠀⠀⠀⣾⠁⢀⣠⡴⠛⢻⡄⠀⠀⠀⠀⠀⠀⠀⠀⣿⣧⡇⣾⣿⣿⠃⠀⠀⠀⠀⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⡿⣄⠀⠙⢻⠀⠀⢀⣾⠁⠀⠀⣼⠇⣠⣿⠁⠀⡟⠀⢀⡟⠀⠀⠀⠀⠀⢠⠟⠳⢦⣀⠀⠀⠀⠀⡿⠀⠀⠀⠀⠀⠲⣿⠴⠋⠀⠀⠀⠀⣷⠀⡄⠀⠀⠀⠀⠀⢀⣿⣯⣇⢾⢇⣿⠄⠀⠀⠀⠀⠀⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⣧⡈⠙⠒⠾⣦⣲⡾⠁⠀⠀⢀⣿⣴⢛⡟⠀⢸⠃⠀⢐⡗⠀⠀⠀⠀⢠⠟⠀⠀⠀⠈⠓⠦⣄⣀⣿⣀⠀⠀⠀⠀⢠⡏⠀⠀⠀⢀⣀⡤⢾⡟⠃⠀⠀⠀⠀⠀⢨⡇⢸⣼⣿⣿⡟⠀⠀⠀⠀⠀⢰⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠊⠻⠦⣤⣴⠟⠂⠀⠀⠀⠀⢘⣿⢁⣰⠃⠀⢸⠀⠀⢸⠄⠀⠀⠀⢀⡞⠀⠀⠀⣀⣤⠴⠚⠋⠀⠹⡇⠀⠀⠀⠀⣼⣤⡤⠖⠛⠉⠀⠀⠀⣇⠀⠀⠀⠀⠀⠀⣸⣷⢼⠘⣿⣿⡄⠀⠀⠀⠀⠀⠰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⠁⠀⠀⢰⡞⢹⣦⡀⠀⠀⣠⡀⢸⠏⣲⡏⠀⠀⣻⠀⠀⣸⡅⠀⠀⢠⣾⣠⠴⠖⠋⠁⠀⠀⠀⠀⠀⠀⠻⡅⠀⠀⢀⡏⠉⠓⠦⣄⡀⠀⠀⠀⣿⣄⠀⠀⠀⠀⠀⣿⡋⠻⣦⣟⣻⠁⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣸⠃⠀⠀⢰⠟⠀⢸⠂⡏⠉⠙⠻⢤⡟⣲⡟⠀⠀⠀⣧⠀⣼⠛⡇⠀⠀⡾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⡄⠀⣼⠃⠀⠀⠀⠀⠉⠓⢦⣀⣺⡆⠀⠀⠀⠀⠀⣾⣥⡀⣸⡿⡟⠀⠀⠀⠀⠀⠀⢸⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢠⡏⠀⠀⣰⢟⠀⠀⣸⠀⡇⠀⠀⢠⡞⢒⡿⠁⠀⠀⠀⣻⣴⠓⠚⣧⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀⣼⠶⢤⣄⣀⡀⣀⠹⣄⡏⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⣷⠤⠀⠀⠀⠀⣧⣾⡟⡟⠠⡇⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⣾⠀⠀⣰⠏⠂⠀⢰⣿⠀⣧⣠⠶⠋⢀⣼⠁⠀⠀⠀⠀⠘⠏⠀⠀⢿⡀⡿⢷⠀⠀⠀⠀⠀⠀⣸⠳⠀⠀⠀⠀⠉⠉⠉⠉⠉⠉⠉⠳⡄⠀⠀⠀⠀⠀⠀⣿⡂⠀⠀⠀⣸⣿⡿⢠⠃⠐⡇⠀⠀⠀⠀⠀⠀⢸⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠸⢷⣄⣰⠋⠀⠀⠀⢸⣿⠀⠈⠁⢀⣰⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣇⠘⢷⣄⠀⠀⠀⢰⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡆⠀⠀⠀⠀⢸⢟⡇⠀⠀⢀⣿⣿⠁⡎⠀⢠⡇⠀⠀⠀⠀⠀⠀⢸⡂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠀⠀⠀⠀⠘⠻⡦⢶⣾⣏⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢧⠀⠀⡟⠳⢤⣀⢸⡃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⠀⠀⠀⠀⣾⠀⣧⠀⠀⣸⣿⣟⣺⠃⠀⢸⡇⠀⠀⠀⠀⠀⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢙⡟⠒⠒⠢⠤⢤⣄⣀⣀⠀⠀⠀⠈⢧⡀⡇⠀⠀⣽⠛⠿⢤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣆⣀⣠⣴⡏⠀⣿⠀⢀⡟⠚⠛⠁⠀⠀⢼⡇⠀⠀⠀⠀⠀⠀⢸⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠞⡇⠀⠀⠀⠀⠀⠀⠀⢈⡟⠑⠒⠤⣄⣿⣧⢀⣴⡋⠀⠀⠀⣨⣿⡏⠛⣟⠒⣿⠚⢺⡿⠶⣾⡛⠛⠉⠉⠀⡾⢀⣾⢻⡀⡿⠁⠀⠀⠀⠀⠀⠘⡇⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠏⢠⡟⠀⠀⠀⠀⠀⠀⠀⣸⠁⠀⠀⠀⠀⠙⠻⠛⠁⠉⠙⠒⢦⡟⠀⠻⣤⣿⣿⣅⢲⡿⠉⣄⡏⠙⣆⠀⠀⣾⠟⠋⠀⢾⡿⠁⠀⠀⠀⠀⠀⠀⢸⡧⠀⠀⠀⠀⠀⠀⠰⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠁⠀⡾⠀⠀⠀⠀⠀⠀⠀⢠⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⢀⡟⢶⡏⠙⠁⠀⣾⣣⡀⠘⣧⣴⣃⠀⠀⠀⠙⠁⠀⠀⠀⠀⠀⠀⠀⠰⣿⠀⠀⠀⠀⠀⠀⠐⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⡼⠁⠀⠀⠀⠀⠀⠀⢀⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⠀⣸⠁⣸⡇⠀⠀⠀⠻⣿⢷⣀⣸⡄⢹⡍⠙⠋⠛⠲⡖⢦⡀⠀⠀⠀⠀⠀⢸⡄⠀⠀⠀⠀⠀⠀⢻⠛⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠴⠋⠀⠀⢀⡴⠁⠀⠀⠀⠀⠀⠀⠀⡼⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣴⡖⣿⡇⠀⢠⡏⠀⠻⡃⠀⠀⠀⣶⣏⣨⣿⣿⣹⠟⠀⠀⠀⠀⠀⣧⠀⣷⠀⠀⠀⠀⠀⠀⣇⠀⠀⠀⠀⠀⠀⠘⡆⠈⠧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⣀⡶⠏⠀⠀⠀⠀⢰⡾⠀⠀⠀⠀⠀⠀⠀⠀⣸⠁⠀⠀⠀⠀⠀⠀⠀⠀⢸⡿⢿⣶⣸⡷⠈⡇⠀⣾⠀⠀⢸⡇⠀⠀⢾⡏⢿⣿⣿⣇⠀⠀⠀⠀⠀⠀⠀⡿⠀⡿⢿⡀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⣿⡀⠀⠉⢆⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠈⢿⡁⠋⠚⠋⠉⠁⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⣰⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⡿⠋⠀⠀⠙⣦⡏⠀⠀⢸⡇⠀⣴⡾⠀⢺⡿⢿⣭⣧⡀⠀⠀⠀⢀⡴⠃⣼⢃⡿⠁⠀⠀⠀⠀⠺⡅⠀⠀⠀⠀⠀⠀⠈⠁⠀⠀⠀⠉⠲⢄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠉⠓⠒⠢⠆⢶⡦⠶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣄⢣⣷⡄⠀⠀⠀⡾⠀⠀⠀⢸⡟⠛⠉⠀⠀⠈⢳⣼⠀⡿⢿⡖⠒⠚⠉⢀⣴⠷⠚⠁⠀⠀⠀⠀⠀⠀⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠓⠒⠦⠤⠤⢦⣴⡶⠞⠃⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡾⢧⢻⣆⣀⣼⠇⠀⠀⠀⢸⣇⠀⠀⠀⢀⣠⢾⡟⣿⠃⠀⠙⠒⠒⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣦⣤⣴⠒⠋⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⡤⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣤⣿⢯⡁⢻⠀⠀⠀⠀⣸⢿⠦⣄⣰⣏⣠⣟⡴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠓⠲⠤⠤⢄⣀⣀⡀⠀",
-            "⠀⠀⠀⠀⣠⠔⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡼⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⣤⣉⠚⣆⠀⠀⣠⣿⣼⣤⠜⢛⣹⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡽⠃",
-            "⠐⢶⡚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠖⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡷⢌⣉⢻⣷⣴⠿⠻⣿⣖⢻⡏⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠀⠀",
-            "⠀⠀⠉⠓⠦⢄⣀⡀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠊⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣧⠀⠀⠈⡇⠉⠀⢠⡏⠀⢹⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡤⠚⠁⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠉⠉⠃⠙⠋⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⡆⠀⠀⡇⠀⠀⠸⣧⣴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠢⢄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠚⠁⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧⠀⠀⣿⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠛⠒⠒⠃⠛⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣷⣙⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣴⣦⣶⣤⣤⣀⣀⣤⣤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣾⠿⠿⣶⣦⣄⡀⠀⢀⣠⣴⣶⠿⠿⠛⠋⠉⠉⠉⠉⠀⠀⠈⠉⠛⠋⠉⠉⠙⠻⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⠏⠀⣠⣄⡀⠈⠙⣿⡾⠟⠋⠁⢀⣀⡤⠶⠖⠛⠛⠲⠞⠋⠉⠛⠛⠒⠲⢿⣷⣦⣄⠀⠉⠻⣷⣶⣤⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⣶⡶⠾⠾⠿⠃⢀⣼⣿⣻⣿⡏⠀⠉⣀⣤⠶⠞⠉⢁⠠⠀⠄⡒⠀⠄⠂⠌⢀⠡⠐⠀⠀⠀⠈⠙⢿⣿⣦⣀⠀⠀⠈⠙⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⡿⠟⠃⠀⣀⣀⡀⠀⠀⣼⡿⣧⣿⣿⠇⢀⡼⠛⠀⠀⡀⠘⢀⠀⠄⢠⠃⠠⢀⠘⠀⠄⠀⠄⡀⠀⠀⠀⠀⠀⠸⢿⣿⣧⡀⠛⢧⡀⠘⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⠋⠀⡠⠞⠋⠀⠀⠀⢀⣾⣿⣽⣿⣿⡿⣿⠋⠀⠄⠂⢁⠠⠈⡀⠄⢈⡏⢀⠐⠠⠀⡁⠂⢁⠠⠀⠀⠀⠀⢀⠀⡀⠈⠹⣟⣿⣦⠀⢻⡄⠈⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⣠⠞⠀⡀⠀⠀⠀⠀⣾⣿⣳⣿⡿⢃⡾⠁⠀⠀⠂⢈⠀⢄⠞⠀⡐⣘⠀⠄⠂⠠⠁⡀⠌⠀⠀⠀⠀⠀⠀⠀⠁⠀⠐⡀⠙⣿⣿⠀⡀⢿⠀⠈⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⢰⢏⣾⣿⣶⣎⣠⣤⣼⣿⣿⣿⡿⠁⣼⠃⠀⠀⠀⠀⠀⣀⡞⠀⡐⠀⣷⠀⠀⢈⠀⠐⠀⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢂⠠⠀⠸⡟⢀⠐⣸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⠃⢀⣿⣾⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢃⢰⡇⠀⠀⠀⠀⠀⠀⡼⠀⠀⠄⠂⣽⣄⠀⠀⠀⢀⠀⠙⠧⣄⠀⠠⠀⠄⢀⠠⠐⠀⡀⢧⡐⠀⢂⠰⢸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣄⣀⣼⡟⠀⣸⣟⣿⣽⣿⣟⠻⢿⣿⣼⣿⣿⣿⢊⣼⢡⠀⠀⠀⠀⠀⣸⠇⠀⠀⠐⢀⡇⠸⣦⡀⢈⠀⠀⠀⣇⠈⠛⣦⣐⠈⠀⠄⠂⡐⠀⡀⢧⠐⡀⢎⣹⠇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⠿⡷⡟⠿⢋⠿⢿⡿⠛⠀⢀⣼⠟⢸⣿⣿⢥⡟⣿⠀⠀⠀⠀⣰⠏⠀⡀⠄⠀⣸⠁⠀⡼⣿⣦⡀⠡⠀⠹⡄⠀⠀⠽⢷⣌⠀⠂⠄⠂⡀⠘⡄⠸⣄⢻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣧⣛⠴⣩⠝⡊⠅⠀⠀⠀⣠⣿⠟⠀⣼⣿⣿⡎⣽⣿⠀⠀⠠⣱⠏⠀⢂⢠⠀⢠⣿⣀⡀⠀⠜⣿⣷⣦⡐⠀⢻⡄⠀⠀⣹⣿⣷⣅⠐⠠⢀⠁⡸⢐⠬⣻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⣠⣶⡿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠗⡌⠀⠀⠀⣠⣾⣿⠋⠀⢸⡇⠀⢸⣷⣾⣿⠇⠀⢡⡟⠀⠌⠀⡎⠀⣼⠋⠈⠉⠓⠲⢿⣿⣿⣿⣄⠈⣧⠀⠚⠁⠺⣹⢿⣷⡆⡄⢂⡘⡇⢎⣽⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣭⣛⢩⠁⠀⠀⠀⣠⣾⣿⡟⠁⠀⣰⣾⡇⠀⠈⣿⣿⣿⠁⢨⡿⠁⠐⠠⢁⡇⢐⣿⠀⠀⣄⠀⠀⠈⢻⣿⣿⣿⣇⢾⡇⠀⠀⣀⣼⣿⣿⣿⣷⢆⡜⣹⢂⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⢿⣿⣷⣄⠀⢀⣴⣿⡿⠋⠀⣰⣴⣿⣿⣻⡶⢤⣼⣿⡿⢀⣿⠃⢀⠁⠂⢸⣧⢨⣿⣿⣶⣦⣄⠀⠀⠀⠻⣿⣿⣿⣿⡇⢠⣾⣿⣿⡽⢿⣿⣿⣿⡜⣳⠐⣾⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣟⣛⠻⢿⣷⣝⢿⣿⣧⣾⣿⠟⠁⠀⠀⣿⣿⣿⣋⣼⣷⡛⡟⠿⣿⣼⣟⠀⠤⠈⢀⣿⣿⣸⣿⣿⡟⣻⠝⢧⠀⠀⠀⠈⠻⣿⣿⢷⣿⣿⣿⣼⡇⠈⣿⣿⣿⣞⠱⠈⣾⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢸⣿⣿⣿⣿⣿⢿⣿⣿⣿⣿⣿⣷⣤⠙⣿⣧⢿⣿⣿⠃⠀⡀⠀⠀⣿⡟⣿⣧⣿⣿⣿⣼⢲⡌⡽⣿⣤⠀⢂⢰⣿⣿⣿⠿⡿⠛⣿⠄⠀⠀⠀⠀⠀⠀⠈⠹⠎⢯⣙⠉⣸⠃⠸⢫⣿⣿⣯⠆⠁⢾⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢸⣿⣿⣿⣿⡏⣼⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣾⣿⡇⠀⠠⠆⣠⣼⣿⢀⣿⣿⣿⣿⣿⣿⣿⣼⠡⠎⠻⣿⣤⣼⡗⠻⠻⠦⣤⠴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⠛⠁⠀⠀⣾⠘⣿⠛⡇⢈⢚⡇⠀⢸⣯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢸⣿⣿⣿⣿⡅⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⡇⠀⢸⣿⣿⢿⣧⣼⣿⣿⣿⣿⣿⣿⣿⣿⣧⠉⠋⠙⠙⢻⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⡁⠠⠁⠂⡸⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⢸⣿⣿⡽⣿⣧⠹⣿⣿⣿⣿⣿⣿⣿⠏⣼⣿⣽⣿⡇⣰⠏⢸⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⡿⢛⠷⠈⠀⠀⠀⠀⠹⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⢤⣿⡇⠐⠀⡁⠄⢁⠰⣿⠀⠈⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠘⢿⣿⣿⣿⣿⣷⣬⣙⡛⠿⣻⣿⣫⣾⣿⣏⣿⣿⡶⠋⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠃⠀⠀⠀⠀⠀⠀⢠⣿⣟⣳⣄⠀⠀⠀⠀⠀⠠⣴⣶⣶⣶⣾⠗⠀⠀⠀⣴⣿⣿⣿⠀⠂⠠⠐⢀⠐⣿⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠻⣿⣼⣿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢿⠏⠀⣴⢿⡝⠁⠈⠉⠙⢿⣿⣿⣿⣿⣟⠀⠀⠀⠀⠀⠀⠀⣀⣼⣯⣿⡟⠻⣷⣄⡀⠀⠀⠀⠈⠉⠉⠉⠁⠀⢀⣴⣾⣿⣿⣿⣿⡇⠀⡁⠐⡀⠂⣽⡇⠀⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠐⣿⡧⣿⡿⢿⣻⣯⡿⣿⣯⣿⣾⢧⡟⠃⢠⣼⡟⡎⠀⠉⠉⠙⠛⠳⡞⣿⣿⣿⡇⠀⢀⣤⣤⣀⠀⣴⣿⡿⠟⠉⠙⢦⣽⣿⠿⢦⣤⣀⠀⠀⠀⠀⣰⠛⢻⣿⣿⣿⣿⣿⣿⣷⠀⠄⢁⠠⠐⡸⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣿⣷⣉⣿⣿⣿⣿⣿⣶⡝⣷⢿⣾⠃⣠⣾⣿⢇⡟⢀⡀⠐⠀⠀⠀⣇⢸⣿⣿⠇⠐⠋⠀⠀⢘⣿⡿⠋⠀⣠⡆⠀⣾⡟⣿⣿⣾⣿⣿⣿⣷⣾⣿⢿⡇⢸⣿⣿⣿⣿⣿⣿⡿⠀⢈⠀⠄⠂⠱⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣿⣿⣿⣟⣿⣿⣿⣿⣿⣿⢸⣿⣿⢠⣿⣿⣿⢸⣷⡸⢿⣦⣄⠀⣰⣇⣾⣿⣿⠂⠈⡀⠀⠀⣸⠋⠀⣠⣾⠟⠀⢠⡟⠻⠿⠛⠋⠀⠉⠉⠙⠿⠿⣦⡁⢿⣿⣿⣿⣿⣿⣿⡇⠀⢂⠀⠂⠌⠐⣿⠀⠘⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⣽⣿⣿⣿⢹⣿⣿⣿⣿⡿⣸⣿⣏⣾⣿⣿⡯⣾⡿⠷⢮⣽⣿⣶⣿⠿⠻⡉⠟⣶⣀⠑⠤⠀⡿⠲⣶⡿⠋⠀⣀⠾⠁⠀⠀⠀⠀⠀⠀⠀⢰⡤⠴⠟⢧⡌⠻⢿⣿⣿⣿⣿⠃⠀⠌⠐⡀⠄⠐⣻⡀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠠⣿⣿⣯⠻⣷⣍⣛⣛⢻⣴⣿⠟⣱⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠠⣅⣜⠠⠙⣿⣶⣄⣼⢧⡀⠈⠀⣀⣾⣟⣓⠂⠄⠀⠀⠀⠀⠀⠀⠘⠷⣤⣀⢨⡿⢷⣤⡈⠛⠛⠉⠋⠻⠶⣶⣦⣄⠂⢹⡇⠀⢿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢻⣿⣿⣷⣮⣙⡛⢛⢻⣻⣥⣿⣿⣿⣿⠟⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⣠⣿⣿⣿⣿⡄⠙⣄⠚⠉⠁⠀⠉⠙⣆⠈⠐⠠⠀⠀⠀⠀⠀⠈⢷⡄⠘⢦⡉⠉⠳⢦⡙⢦⠀⠀⠀⠉⠺⡛⢶⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢁⠠⢠⠀⡄⢠⠀⠠⢀⠀⠀⠀⠀⠀⢀⡞⠙⣿⣿⣿⣿⡄⠹⡆⠀⠀⠀⠀⠀⢯⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡄⢀⠳⣤⠀⠀⠁⠈⠳⡀⠀⠀⠀⠈⢢⡻⡄⠸⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣤⢃⠦⣡⠒⠤⠘⠠⠀⠀⠀⠀⣀⣤⠟⠁⢸⣿⣿⣿⣿⣿⡀⢹⡄⠀⠀⠀⠀⠩⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣆⠀⡈⠳⣄⠀⠀⠀⠙⢦⡀⡀⠀⠀⠙⣇⠀⠈⢻⡿⢿⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⠿⠶⠿⠾⠷⠷⠶⠾⠟⠛⠉⠁⠀⡘⣿⣿⣿⣿⣿⣿⡇⠘⣧⠀⠀⠀⠀⢸⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣧⡀⠐⠘⢷⣄⠉⠦⠿⣇⠁⠀⠀⠀⠈⠳⢦⣀⣧⡀⠈⠻⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡼⢅⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⣼⣿⣿⣿⣿⣿⣿⡿⢀⣿⠀⠀⠀⠀⢠⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣷⡈⢀⠂⠙⢿⡶⠶⠿⠶⢦⡀⠀⠀⠀⠀⠀⠙⣿⣦⠀⠙⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠰⢠⢂⠠⢀⡀⠀⠀⠀⠀⠀⢀⣡⣿⣿⣿⣿⣿⣿⣿⡇⢸⡇⠀⠀⠀⠀⢸⡇⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡆⠠⠁⡈⠱⡆⠀⠀⠲⣕⡀⠀⠀⠀⠀⢀⡟⣿⣷⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢦⡙⡆⢬⡑⢢⠠⣉⣄⣠⡴⠞⠋⣿⣿⣿⣿⣿⣿⣿⡟⠀⡾⠀⠀⠀⠀⠀⣼⠄⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⡀⠐⡀⠁⠹⡄⠀⠀⠘⢿⡄⠀⠀⣠⡾⢁⣿⣿⣿⣦⡀⠨⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⠛⣿⣿⣿⣿⡟⡟⠛⠛⠛⠿⠛⠿⠛⠛⠟⠛⠉⠁⠠⣄⣾⣿⣿⣿⣿⣿⣿⡟⠁⣼⠁⠀⠀⠀⠀⢸⡏⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠠⢀⠁⠂⢿⠀⠀⠀⠀⣿⣦⡾⢋⣴⣿⣿⣿⣿⣿⣿⣦⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀⣘⣿⣿⣿⣿⡱⠡⠌⢂⣄⡀⠀⠄⢂⡀⠀⠀⠄⣱⣾⣿⣿⣿⣿⣿⡿⠋⣠⢾⡇⠀⠀⠀⠀⢠⣞⢁⣸⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠈⠄⡘⣇⠀⠀⠀⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠈⢻⣧⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⢸⡏⠀⢹⣿⣿⣿⣿⣇⠻⣌⠲⣌⠷⢬⠐⠠⢀⠂⣀⣴⣿⣿⣿⣿⠿⠛⢁⣤⠞⠁⠈⣿⣄⠀⠀⢀⣾⠇⣼⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠡⠀⠄⢿⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠈⣿⡆⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⡿⠈⠻⣿⡿⢿⢷⣾⣿⣾⣽⣦⣭⣶⠟⠛⠛⠛⠛⢉⣉⣠⡴⠞⠋⠀⣠⣶⡀⠘⢿⣦⣶⡿⠋⠚⠛⠓⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⡗⠠⠐⠀⠡⠀⢼⡆⠀⠀⢹⣿⡏⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⢰⣿⠀⢰⡇⠠⢀⠀⢀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣾⠛⠛⠉⠁⣀⣤⣶⠿⠛⠻⣿⡀⠸⣿⡿⡖⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⢀⠂⢁⠂⢁⠀⣧⠀⠀⠸⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⣼⡏⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⣸⡏⠀⣸⠀⠠⠀⠌⠀⠠⠈⢀⠐⠀⠂⠀⠈⠉⢉⣿⣿⣿⠀⢰⣾⠿⠛⠉⠀⠀⠀⠀⢿⣧⠀⢸⣷⣷⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣇⠀⡐⠠⠐⠀⢂⢻⠀⠀⢸⣿⣿⣿⠟⣻⣿⣿⣿⣻⡟⣿⣿⡟⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⣿⠀⡀⢁⠂⠈⠀⠄⠂⠀⠌⠀⠁⠀⠀⣾⣿⣿⣿⠀⠈⣿⠄⠀⠀⠀⠀⠀⠀⠩⣿⣆⠀⢻⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠠⠐⡀⠡⢀⢸⡆⠀⢸⣿⣿⣥⣿⣿⣿⣿⣿⣿⡿⠈⣿⠀⢠⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⢀⣿⠀⢰⡇⠀⠄⡀⠂⢁⠀⠂⢀⠐⠀⣈⣤⣄⣾⣿⣿⣿⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠸⣿⡄⠈⢿⣧⠤⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠡⠐⢀⠐⡀⠈⣷⠀⢸⣿⣿⣿⣿⣿⣿⣿⡿⡿⠁⣰⠇⠀⣾⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⣸⡟⠀⢸⠃⢀⠂⠠⠐⠀⡀⠌⠀⠀⠄⣾⣿⣿⣿⢿⣿⣿⣿⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⢻⣷⡀⠘⣿⣆⠀⢀⠠⠐⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡅⠂⢈⠠⠀⠄⡁⠸⡆⢸⣿⣿⣿⣿⣿⣿⡿⢱⣇⣀⡟⠀⣼⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⣿⡇⠀⡿⠀⠠⠀⡁⢀⠂⠀⠠⠐⠈⠀⣿⣿⣿⣯⣿⣿⣿⣿⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣧⠀⢹⣿⡄⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⢂⠠⠈⡀⠄⠁⢿⣻⣿⣿⣿⣿⣿⡿⢠⣟⣼⡿⠁⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢠⣿⠀⢰⡇⠀⡁⠠⠐⠀⠀⠀⠂⠀⠄⣠⣿⣿⣿⣟⣿⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡄⠀⢻⣧⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣻⣇⠈⡀⠄⠂⡀⠂⢁⠘⣿⣿⣿⣿⣿⣿⣥⡟⡴⣼⠃⢀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⢸⣿⠀⢸⡇⠀⡄⠐⢠⠀⠁⠀⡄⣴⣾⣿⣿⣿⣿⣿⢻⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⡄⠈⣿⡆⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⠀⡄⠂⠁⢠⠈⢠⠀⢹⣿⣿⣿⢻⣿⣾⢳⢳⡏⠀⣼⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⢀⣾⡇⠀⣾⣄⣀⣄⣐⣀⣀⣀⣠⣾⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡀⢸⣿⣠⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣧⠀⣹⣿⣤⣀⣀⣀⣀⣀⣀⡀⠀⠀⠀⠀⠀⣀⣀⣸⣿⣀⣠⣔⣈⣤⣐⣀⣈⣀⣈⣹⣿⣿⣾⣷⣏⣾⠁⣠⣿⡃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠈⠀⠈⠁⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠈⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-        vec![
-            "",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣤⣤⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣷⣷⣷⣷⣆⠀⢀⣀⣀⣀⣀⣀⠀⢠⣾⣿⡟⢻⣿⣷⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣯⣴⡿⣟⠛⡏⢭⢩⡙⡍⣛⠻⣾⣿⣿⣷⢾⣿⡿⡛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⡿⣿⣧⡓⡌⣿⡉⢦⠡⡜⢰⢡⢺⣿⣿⢻⣿⡧⡘⢟⣿⡇⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣟⡛⢼⡏⡔⢢⢱⣿⡜⣂⠓⡬⢑⠦⣿⣿⣿⢒⢤⠓⡘⢆⠲⡹⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⢣⡷⡘⣾⡗⢬⢃⣾⠋⠻⢦⣝⣴⣉⡖⢿⣍⢻⣿⢢⠙⡬⢌⡑⢆⠭⢷⡄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡟⣿⡇⣿⠣⣿⡇⢻⣎⠦⡟⠀⠀⢀⡈⠙⣿⣖⢹⣧⣣⢹⣧⠍⡔⢣⡘⢌⢆⢣⠻⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢏⢲⡟⣸⣿⣡⡿⣺⣆⠹⠻⠇⠠⣾⣻⣿⣽⡿⠽⠷⣿⢦⢩⢹⣾⢈⠦⣑⠪⠌⡆⢣⡙⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠻⣼⢹⡧⣿⣿⢷⣿⣿⠿⠿⣆⠀⠀⠈⠩⡏⠋⠁⠀⠠⢸⡍⣆⠃⣿⣎⠲⢌⡜⠱⣨⠱⡨⢍⢻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⡜⢄⠯⣿⡟⣿⣯⣿⠀⠀⢀⣿⣴⣶⣿⡾⠷⠁⠀⠀⠀⢸⡗⣪⢱⡿⠹⣷⠨⠔⣃⠦⣑⠡⢎⠢⡝⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠣⣍⠰⣊⠜⡘⠿⣘⢷⣽⣇⡀⢈⠛⢿⢿⠟⠀⠀⠀⠀⠀⠀⣸⠗⣼⠿⠁⠀⠹⣧⡙⡔⢢⠥⡙⠤⡓⣌⠹⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠣⣍⠰⢃⠴⢩⡘⠥⡘⣌⣿⠿⣟⠾⣥⣀⣀⢀⣀⣀⣠⡤⠶⠚⢿⠟⠋⠀⠀⠀⠀⠙⣷⡌⢥⠒⣩⠒⡡⠜⢢⡉⣷⡤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⡕⢢⡉⢎⠜⢢⠜⢢⣑⡾⠣⠀⠀⠀⠀⠈⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣆⡹⢄⢣⠱⣉⠦⠱⡘⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⢏⠲⠌⡥⢘⠢⢍⡒⡌⣣⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣧⣊⢆⡳⠰⢌⢣⢑⡚⢿⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠟⣊⠲⢩⠔⡩⠜⢢⢜⣴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠚⢷⡦⣘⠱⣊⠤⠣⢜⡸⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣟⡸⢄⣋⠲⢌⡑⢎⣡⡾⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣦⡓⢤⡙⡘⢆⡒⣹⣧⠀⠀⠀⠀⠀⣠⣦⡀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡾⣡⠒⡬⢄⡓⠬⡘⣴⡟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⢿⣤⢃⠝⡢⢜⡰⢹⡶⢞⡛⠷⢾⣯⡜⣿⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢣⡑⡜⢰⠡⠚⣔⣱⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢾⣰⠑⡆⣎⡱⢛⡗⢎⠞⡠⣿⡐⣿⡄",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡏⣆⠱⡈⠇⡎⢱⣾⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⣿⣰⠇⣇⡉⢸⣈⣶⣿⡏⢱⢸⡇",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⢱⣊⠱⢌⠓⣌⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢻⣶⣤⡽⠟⠋⠁⣼⢋⠦⢹⡇",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣟⠢⣅⢋⠴⢩⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⢮⣎⣻⡇",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠬⡓⢌⡒⢜⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⡾⠿⠏⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠳⣌⠱⡊⡔⢳⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣏⠱⣂⢣⠱⡘⢼⠇⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡿⢨⠓⡤⢣⢡⡙⣾⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠧⢃⠭⣐⢃⠦⢹⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⡏⡜⣡⠚⠤⣃⢮⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡿⢱⡘⠤⣙⠲⢰⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⢋⠦⢡⠓⡤⢣⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣄⠀⠀⠀⠀⠀⢠⡯⢱⡉⢦⢉⣶⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⣾⣹⣹⡇⠀⠀⠀⠀⣾⣓⠥⢚⠤⣳⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣶⣿⣿⣿⠿⣸⣗⠀⠀⠀⣰⡗⣌⠚⡤⣳⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠟⣫⠰⡘⡄⢛⢿⣦⣠⡿⡖⠬⡘⣶⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣜⠤⣓⠺⢜⣃⣖⣌⠛⡟⢏⢣⣳⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠷⢦⣧⣎⡡⡖⣨⠱⡘⣌⢲⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣶⢅⠲⡡⢆⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠹⣧⣩⠳⣼⠇⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-            "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
-        ],
-    ];
-
-    if list {
-        // return a vector where each element represents one style
-        // the length of this vector will give us the number of styles
-        let mut result = Vec::new();
-        for _i in 0..styles.len() {
-            result.push(" "); // Simple static string for each style
-        }
-        return result;
-    }
-
-    if style > 0 && style as usize >= styles.len() {
-        panic!(
-            "Style {} does not exist! Choose one between 0 and {}",
-            style,
-            styles.len() - 1
-        );
-    }
-    let selected_style = if style < 0 {
-        rng.random_range(0..styles.len())
-    } else {
-        style as usize
-    };
-    styles[selected_style].clone()
-}
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
deleted file mode 100644
index ea7cfc1..0000000
--- a/tests/integration_tests.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use std::process::Command;
-use std::str;
-
-fn command() -> Command {
-    Command::new(env!("CARGO_BIN_EXE_mikusays"))
-}
-
-#[test]
-fn test_cli_list_styles() {
-    let output = command()
-        .arg("--list")
-        .output()
-        .expect("Failed to execute command");
-
-    assert!(output.status.success());
-    let stdout = str::from_utf8(&output.stdout).expect("Invalid UTF-8");
-
-    // Should contain style listing information
-    assert!(stdout.contains("Available Miku art styles:"));
-    assert!(stdout.contains("Total styles:"));
-    assert!(stdout.contains("--- Style"));
-}
-
-#[test]
-fn test_cli_error_no_text() {
-    let output = command().output().expect("Failed to execute command");
-
-    assert!(!output.status.success());
-    let stderr = str::from_utf8(&output.stderr).expect("Invalid UTF-8");
-    assert!(stderr.contains("Error: Text is required when not using --list"));
-}
-
-#[test]
-fn test_cli_error_conflicting_args() {
-    let output = command()
-        .arg("Test")
-        .arg("--rainbow")
-        .arg("--color")
-        .arg("red")
-        .output()
-        .expect("Failed to execute command");
-
-    assert!(!output.status.success());
-    let stderr = str::from_utf8(&output.stderr).expect("Invalid UTF-8");
-    assert!(stderr.contains("cannot be used with"));
-}
-
-#[test]
-fn test_cli_basic_functionality() {
-    // Test that the binary runs and produces some output
-    let output = command()
-        .arg("--list")
-        .output()
-        .expect("Failed to execute command");
-
-    assert!(output.status.success());
-}
-
-#[test]
-fn test_cli_no_color_overrides_solid_color() {
-    let output = command()
-        .args(["test", "--style", "0", "--color", "red", "--no-color"])
-        .env("TERM", "xterm-256color")
-        .output()
-        .expect("Failed to execute command");
-
-    assert!(output.status.success());
-    assert!(!output.stdout.contains(&0x1b));
-}
-
-#[test]
-fn test_cli_no_color_environment_overrides_gradient() {
-    let output = command()
-        .args(["test", "--style", "0", "--gradient", "red:blue"])
-        .env("NO_COLOR", "1")
-        .env("TERM", "xterm-256color")
-        .output()
-        .expect("Failed to execute command");
-
-    assert!(output.status.success());
-    assert!(!output.stdout.contains(&0x1b));
-}
-
-#[test]
-fn test_cli_rejects_out_of_range_style_without_panicking() {
-    let output = command()
-        .args(["test", "--style", "999"])
-        .output()
-        .expect("Failed to execute command");
-
-    assert_eq!(output.status.code(), Some(2));
-    let stderr = str::from_utf8(&output.stderr).expect("Invalid UTF-8");
-    assert!(stderr.contains("style 999 does not exist"));
-    assert!(!stderr.contains("panicked"));
-}
-
-#[test]
-fn test_cli_rejects_negative_style() {
-    let output = command()
-        .args(["test", "--style", "-1"])
-        .output()
-        .expect("Failed to execute command");
-
-    assert_eq!(output.status.code(), Some(2));
-    let stderr = str::from_utf8(&output.stderr).expect("Invalid UTF-8");
-    assert!(!stderr.contains("panicked"));
-}
-
-#[test]
-fn test_cli_rejects_out_of_range_saturation() {
-    let output = command()
-        .args(["test", "--rainbow", "--saturation", "101"])
-        .output()
-        .expect("Failed to execute command");
-
-    assert_eq!(output.status.code(), Some(2));
-}
-
-#[test]
-fn test_cli_rejects_invalid_color() {
-    let output = command()
-        .args(["test", "--color", "not-a-color"])
-        .output()
-        .expect("Failed to execute command");
-
-    assert_eq!(output.status.code(), Some(2));
-    let stderr = str::from_utf8(&output.stderr).expect("Invalid UTF-8");
-    assert!(stderr.contains("invalid color 'not-a-color'"));
-}